diff --git a/src/Compilers/CSharp/Portable/CSharpFileSystemExtensions.cs b/src/Compilers/CSharp/Portable/CSharpFileSystemExtensions.cs
index f756731db82f0..5c08374d3c392 100644
--- a/src/Compilers/CSharp/Portable/CSharpFileSystemExtensions.cs
+++ b/src/Compilers/CSharp/Portable/CSharpFileSystemExtensions.cs
@@ -7,6 +7,7 @@
 using System.IO;
 using System.Threading;
 using Microsoft.CodeAnalysis.Emit;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -21,13 +22,14 @@ public static class CSharpFileSystemExtensions
         /// Also embedded in the output file.  Null to forego PDB generation.
         /// </param>
         /// <param name="xmlDocumentationPath">Path of the file to which the compilation's XML documentation will be written.  Null to forego XML generation.</param>
-        /// <param name="win32ResourcesPath">Path of the file from which the compilation's Win32 resources will be read (in RES format).  
+        /// <param name="win32ResourcesPath">Path of the file from which the compilation's Win32 resources will be read (in RES format).
         /// Null to indicate that there are none.</param>
         /// <param name="manifestResources">List of the compilation's managed resources.  Null to indicate that there are none.</param>
         /// <param name="cancellationToken">To cancel the emit process.</param>
         /// <exception cref="ArgumentNullException">Compilation or path is null.</exception>
         /// <exception cref="ArgumentException">Path is empty or invalid.</exception>
         /// <exception cref="IOException">An error occurred while reading or writing a file.</exception>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public static EmitResult Emit(
             this CSharpCompilation compilation,
             string outputPath,
diff --git a/src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs b/src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs
index 4b62175029b82..959a13b857938 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs
@@ -330,6 +330,7 @@ protected override bool TryGetCompilerDiagnosticCode(string diagnosticId, out ui
             return CommonCompiler.TryGetCompilerDiagnosticCode(diagnosticId, "CS", out code);
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
         protected override void ResolveAnalyzersFromArguments(
             List<DiagnosticInfo> diagnostics,
             CommonMessageProvider messageProvider,
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index 64f4f26d066bd..5cefa20203e89 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -3622,6 +3622,7 @@ private IEnumerable<string> AddedModulesResourceNames(DiagnosticBag diagnostics)
             }
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal override EmitDifferenceResult EmitDifference(
             EmitBaseline baseline,
             IEnumerable<SemanticEdit> edits,
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
index 174ed359247c1..8af5f6386fdad 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
@@ -19,6 +19,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Emit
 {
     internal static class EmitHelpers
     {
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal static EmitDifferenceResult EmitDifference(
             CSharpCompilation compilation,
             EmitBaseline baseline,
diff --git a/src/Compilers/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.csproj b/src/Compilers/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.csproj
index 41749fc9389f8..c84b0ff2a8427 100644
--- a/src/Compilers/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.csproj
+++ b/src/Compilers/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.csproj
@@ -19,6 +19,12 @@
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <CompilerGeneratedFilesOutputPath>Generated</CompilerGeneratedFilesOutputPath>
   </PropertyGroup>
+
+  <!-- Enable trimming/AOT compat -->
+  <PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <IsAotCompatible>true</IsAotCompatible>
+  </PropertyGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\Core\Portable\Microsoft.CodeAnalysis.csproj" />
     <ProjectReference Include="..\..\..\Tools\Source\CompilerGeneratorTools\Source\CSharpSyntaxGenerator\CSharpSyntaxGenerator.csproj">
diff --git a/src/Compilers/Core/CodeAnalysisTest/ObjectSerializationTests.cs b/src/Compilers/Core/CodeAnalysisTest/ObjectSerializationTests.cs
index ee863386965cf..cbbc6bc0be6b4 100644
--- a/src/Compilers/Core/CodeAnalysisTest/ObjectSerializationTests.cs
+++ b/src/Compilers/Core/CodeAnalysisTest/ObjectSerializationTests.cs
@@ -425,19 +425,6 @@ public void TestUInt32TypeCodes()
             Assert.Equal(ObjectWriter.TypeCode.UInt32_10, ObjectWriter.TypeCode.UInt32_0 + 10);
         }
 
-        private void TestRoundTripType(Type type)
-        {
-            TestRoundTrip(type, (w, v) => w.WriteType(v), r => r.ReadType());
-        }
-
-        [Fact]
-        public void TestTypes()
-        {
-            TestRoundTripType(typeof(int));
-            TestRoundTripType(typeof(string));
-            TestRoundTripType(typeof(ObjectSerializationTests));
-        }
-
         private void TestRoundTripCompressedUint(uint value)
         {
             TestRoundTrip(value, (w, v) => ((ObjectWriter)w).WriteCompressedUInt(v), r => ((ObjectReader)r).ReadCompressedUInt());
diff --git a/src/Compilers/Core/MSBuildTask/Microsoft.Build.Tasks.CodeAnalysis.csproj b/src/Compilers/Core/MSBuildTask/Microsoft.Build.Tasks.CodeAnalysis.csproj
index add856e63337d..6ba568e393beb 100644
--- a/src/Compilers/Core/MSBuildTask/Microsoft.Build.Tasks.CodeAnalysis.csproj
+++ b/src/Compilers/Core/MSBuildTask/Microsoft.Build.Tasks.CodeAnalysis.csproj
@@ -10,7 +10,7 @@
     <AutoGenerateAssemblyVersion>true</AutoGenerateAssemblyVersion>
 
     <!--
-      Prevent the generation of binding redirects as they are not respected by 
+      Prevent the generation of binding redirects as they are not respected by
       MSBuild. At the moment it's on by default due to arcade settings that we
       need to override here
 
@@ -57,6 +57,9 @@
     <Compile Include="..\Portable\InternalUtilities\NullableAttributes.cs" />
     <Compile Include="..\Portable\InternalUtilities\PlatformInformation.cs" />
     <Compile Include="..\Portable\InternalUtilities\ReflectionUtilities.cs" />
+    <Compile Include="..\Portable\InternalUtilities\TrimWarningMessages.cs" />
+    <Compile Include="..\Portable\InternalUtilities\DynamicallyAccessedMembersAttribute.cs" />
+    <Compile Include="..\Portable\InternalUtilities\RequiresUnreferencedCodeAttribute.cs" />
     <Compile Include="..\Portable\InternalUtilities\RoslynString.cs" />
     <Compile Include="..\Portable\InternalUtilities\UnicodeCharacterUtilities.cs" />
   </ItemGroup>
diff --git a/src/Compilers/Core/Portable/CodeAnalysisEventSource.cs b/src/Compilers/Core/Portable/CodeAnalysisEventSource.cs
index 8c14035b2cdc3..066402f248251 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisEventSource.cs
+++ b/src/Compilers/Core/Portable/CodeAnalysisEventSource.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Tracing;
 using Roslyn.Utilities;
 
diff --git a/src/Compilers/Core/Portable/CommandLine/CommandLineArguments.cs b/src/Compilers/Core/Portable/CommandLine/CommandLineArguments.cs
index cc79c598cd69f..b69925aec3b42 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommandLineArguments.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommandLineArguments.cs
@@ -98,7 +98,7 @@ public abstract class CommandLineArguments
         public string? PdbPath { get; internal set; }
 
         /// <summary>
-        /// Path of the file containing information linking the compilation to source server that stores 
+        /// Path of the file containing information linking the compilation to source server that stores
         /// a snapshot of the source code included in the compilation.
         /// </summary>
         public string? SourceLink { get; internal set; }
@@ -151,7 +151,7 @@ public abstract class CommandLineArguments
         public ImmutableArray<Diagnostic> Errors { get; internal set; }
 
         /// <summary>
-        /// References to metadata supplied on the command line. 
+        /// References to metadata supplied on the command line.
         /// Includes assemblies specified via /r and netmodules specified via /addmodule.
         /// </summary>
         public ImmutableArray<CommandLineReference> MetadataReferences { get; internal set; }
@@ -192,7 +192,7 @@ public abstract class CommandLineArguments
         public bool SkipAnalyzers { get; internal set; }
 
         /// <summary>
-        /// If true, prepend the command line header logo during 
+        /// If true, prepend the command line header logo during
         /// <see cref="CommonCompiler.Run"/>.
         /// </summary>
         public bool DisplayLogo { get; internal set; }
@@ -262,7 +262,7 @@ public abstract class CommandLineArguments
         /// Source file paths.
         /// </summary>
         /// <remarks>
-        /// Includes files specified directly on command line as well as files matching patterns specified 
+        /// Includes files specified directly on command line as well as files matching patterns specified
         /// on command line using '*' and '?' wildcards or /recurse option.
         /// </remarks>
         public ImmutableArray<CommandLineSourceFile> SourceFiles { get; internal set; }
@@ -271,7 +271,7 @@ public abstract class CommandLineArguments
         /// Full path of a log of file paths accessed by the compiler, or null if file logging should be suppressed.
         /// </summary>
         /// <remarks>
-        /// Two log files will be created: 
+        /// Two log files will be created:
         /// One with path <see cref="TouchedFilesPath"/> and extension ".read" logging the files read,
         /// and second with path <see cref="TouchedFilesPath"/> and extension ".write" logging the files written to during compilation.
         /// </remarks>
@@ -319,9 +319,9 @@ internal CommandLineArguments()
         /// Returns a full path of the file that the compiler will generate the assembly to if compilation succeeds.
         /// </summary>
         /// <remarks>
-        /// The method takes <paramref name="outputFileName"/> rather than using the value of <see cref="OutputFileName"/> 
+        /// The method takes <paramref name="outputFileName"/> rather than using the value of <see cref="OutputFileName"/>
         /// since the latter might be unspecified, in which case actual output path can't be determined for C# command line
-        /// without creating a compilation and finding an entry point. VB does not allow <see cref="OutputFileName"/> to 
+        /// without creating a compilation and finding an entry point. VB does not allow <see cref="OutputFileName"/> to
         /// be unspecified.
         /// </remarks>
         public string GetOutputFilePath(string outputFileName)
@@ -335,13 +335,13 @@ public string GetOutputFilePath(string outputFileName)
         }
 
         /// <summary>
-        /// Returns a full path of the PDB file that the compiler will generate the debug symbols to 
+        /// Returns a full path of the PDB file that the compiler will generate the debug symbols to
         /// if <see cref="EmitPdbFile"/> is true and the compilation succeeds.
         /// </summary>
         /// <remarks>
-        /// The method takes <paramref name="outputFileName"/> rather than using the value of <see cref="OutputFileName"/> 
+        /// The method takes <paramref name="outputFileName"/> rather than using the value of <see cref="OutputFileName"/>
         /// since the latter might be unspecified, in which case actual output path can't be determined for C# command line
-        /// without creating a compilation and finding an entry point. VB does not allow <see cref="OutputFileName"/> to 
+        /// without creating a compilation and finding an entry point. VB does not allow <see cref="OutputFileName"/> to
         /// be unspecified.
         /// </remarks>
         public string GetPdbFilePath(string outputFileName)
@@ -458,6 +458,7 @@ internal static ImmutableArray<PortableExecutableReference> ResolveMetadataRefer
         /// </summary>
         /// <param name="analyzerLoader">Load an assembly from a file path</param>
         /// <returns>Yields resolved <see cref="AnalyzerFileReference"/> or <see cref="UnresolvedAnalyzerReference"/>.</returns>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
         public IEnumerable<AnalyzerReference> ResolveAnalyzerReferences(IAnalyzerAssemblyLoader analyzerLoader)
         {
             foreach (CommandLineAnalyzerReference cmdLineReference in AnalyzerReferences)
@@ -467,6 +468,7 @@ public IEnumerable<AnalyzerReference> ResolveAnalyzerReferences(IAnalyzerAssembl
             }
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
         internal void ResolveAnalyzersFromArguments(
             string language,
             List<DiagnosticInfo> diagnostics,
@@ -562,6 +564,7 @@ internal void ResolveAnalyzersFromArguments(
             bool shouldIncludeAnalyzer(DiagnosticAnalyzer analyzer) => !skipAnalyzers || analyzer is DiagnosticSuppressor;
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
         private AnalyzerFileReference? ResolveAnalyzerReference(CommandLineAnalyzerReference reference, IAnalyzerAssemblyLoader analyzerLoader)
         {
             string? resolvedPath = FileUtilities.ResolveRelativePath(reference.FilePath, basePath: null, baseDirectory: BaseDirectory, searchPaths: ReferencePaths, fileExists: File.Exists);
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
index 2aa77fd0bff23..fd882097a1407 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
@@ -113,6 +113,7 @@ public virtual void PrintVersion(TextWriter consoleOutput)
 
         protected abstract bool TryGetCompilerDiagnosticCode(string diagnosticId, out uint code);
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
         protected abstract void ResolveAnalyzersFromArguments(
             List<DiagnosticInfo> diagnostics,
             CommonMessageProvider messageProvider,
@@ -742,6 +743,7 @@ protected virtual void PrintError(Diagnostic diagnostic, TextWriter consoleOutpu
         /// <summary>
         /// csc.exe and vbc.exe entry point.
         /// </summary>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public virtual int Run(TextWriter consoleOutput, CancellationToken cancellationToken = default)
         {
             var saveUICulture = CultureInfo.CurrentUICulture;
@@ -855,6 +857,7 @@ string deriveCacheKey()
 
         private protected abstract GeneratorDriver CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, ImmutableArray<AdditionalText> additionalTexts);
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         private int RunCore(TextWriter consoleOutput, ErrorLogger? errorLogger, CancellationToken cancellationToken)
         {
             Debug.Assert(!Arguments.IsScriptRunner);
@@ -1037,6 +1040,7 @@ private static CompilerAnalyzerConfigOptionsProvider UpdateAnalyzerConfigOptions
         /// (parsing, binding, compile, emit), resulting in diagnostics
         /// and analyzer output.
         /// </summary>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         private void CompileAndEmit(
             TouchedFileLogger? touchedFilesLogger,
             ref Compilation compilation,
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index 67f23a2b75dfb..923a5d4eb8a04 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -2643,6 +2643,7 @@ internal void EnsureAnonymousTypeTemplates(CancellationToken cancellationToken)
 
         // 1.0 BACKCOMPAT OVERLOAD -- DO NOT TOUCH
         [EditorBrowsable(EditorBrowsableState.Never)]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public EmitResult Emit(
             Stream peStream,
             Stream? pdbStream,
@@ -2667,6 +2668,7 @@ public EmitResult Emit(
 
         // 1.3 BACKCOMPAT OVERLOAD -- DO NOT TOUCH
         [EditorBrowsable(EditorBrowsableState.Never)]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public EmitResult Emit(
             Stream peStream,
             Stream pdbStream,
@@ -2691,6 +2693,7 @@ public EmitResult Emit(
         }
 
         // 2.0 BACKCOMPAT OVERLOAD -- DO NOT TOUCH
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public EmitResult Emit(
             Stream peStream,
             Stream? pdbStream,
@@ -2752,6 +2755,7 @@ public EmitResult Emit(
         /// Only supported when emitting Portable PDBs.
         /// </param>
         /// <param name="cancellationToken">To cancel the emit process.</param>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public EmitResult Emit(
             Stream peStream,
             Stream? pdbStream = null,
@@ -2780,6 +2784,7 @@ public EmitResult Emit(
                 cancellationToken);
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal EmitResult Emit(
             Stream peStream,
             Stream? pdbStream,
@@ -2897,6 +2902,7 @@ internal EmitResult Emit(
         /// This overload is only intended to be directly called by tests that want to pass <paramref name="testData"/>.
         /// The map is used for storing a list of methods and their associated IL.
         /// </summary>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal EmitResult Emit(
             Stream peStream,
             Stream? metadataPEStream,
@@ -3009,6 +3015,7 @@ internal EmitResult Emit(
         /// subsequent Edit and Continue.
         /// </summary>
         [Obsolete("UpdatedMethods is now part of EmitDifferenceResult, so you should use an overload that doesn't take it.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public EmitDifferenceResult EmitDifference(
             EmitBaseline baseline,
             IEnumerable<SemanticEdit> edits,
@@ -3029,6 +3036,7 @@ public EmitDifferenceResult EmitDifference(
         /// subsequent Edit and Continue.
         /// </summary>
         [Obsolete("UpdatedMethods is now part of EmitDifferenceResult, so you should use an overload that doesn't take it.")]
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public EmitDifferenceResult EmitDifference(
             EmitBaseline baseline,
             IEnumerable<SemanticEdit> edits,
@@ -3056,6 +3064,7 @@ public EmitDifferenceResult EmitDifference(
         /// of the current compilation is returned as an EmitBaseline for use in a
         /// subsequent Edit and Continue.
         /// </summary>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public EmitDifferenceResult EmitDifference(
             EmitBaseline baseline,
             IEnumerable<SemanticEdit> edits,
@@ -3102,6 +3111,7 @@ public EmitDifferenceResult EmitDifference(
         }
 #pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal abstract EmitDifferenceResult EmitDifference(
             EmitBaseline baseline,
             IEnumerable<SemanticEdit> edits,
@@ -3174,6 +3184,7 @@ internal abstract EmitDifferenceResult EmitDifference(
 
         internal bool IsEmitDeterministic => this.Options.Deterministic;
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal bool SerializeToPeStream(
             CommonPEModuleBuilder moduleBeingBuilt,
             EmitStreamProvider peStreamProvider,
@@ -3326,6 +3337,7 @@ internal bool SerializeToPeStream(
             return auxStream;
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal static bool SerializePeToStream(
             CommonPEModuleBuilder moduleBeingBuilt,
             DiagnosticBag metadataDiagnostics,
@@ -3389,6 +3401,7 @@ internal static bool SerializePeToStream(
             return true;
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal EmitBaseline? SerializeToDeltaStreams(
             CommonPEModuleBuilder moduleBeingBuilt,
             EmitBaseline baseline,
diff --git a/src/Compilers/Core/Portable/DiaSymReader/SymUnmanagedFactory.cs b/src/Compilers/Core/Portable/DiaSymReader/SymUnmanagedFactory.cs
index 499b6b2d86a4e..205b80bb41487 100644
--- a/src/Compilers/Core/Portable/DiaSymReader/SymUnmanagedFactory.cs
+++ b/src/Compilers/Core/Portable/DiaSymReader/SymUnmanagedFactory.cs
@@ -8,7 +8,9 @@
 using System.IO;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Operations;
+using Roslyn.Utilities;
 
 namespace Microsoft.DiaSymReader
 {
@@ -163,6 +165,7 @@ private static Type GetComTypeType(ref Type lazyType, Guid clsid)
             return lazyType;
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal static object CreateObject(bool createReader, bool useAlternativeLoadPath, bool useComRegistry, out string moduleName, out Exception loadException)
         {
             object instance = null;
diff --git a/src/Compilers/Core/Portable/DiaSymReader/Writer/SymUnmanagedWriterFactory.cs b/src/Compilers/Core/Portable/DiaSymReader/Writer/SymUnmanagedWriterFactory.cs
index 44bdefb7754c4..48db049b7fc7f 100644
--- a/src/Compilers/Core/Portable/DiaSymReader/Writer/SymUnmanagedWriterFactory.cs
+++ b/src/Compilers/Core/Portable/DiaSymReader/Writer/SymUnmanagedWriterFactory.cs
@@ -6,6 +6,8 @@
 
 using System;
 using System.Diagnostics;
+using Microsoft.CodeAnalysis;
+using Roslyn.Utilities;
 
 namespace Microsoft.DiaSymReader
 {
@@ -18,17 +20,18 @@ internal static class SymUnmanagedWriterFactory
         /// <param name="options">Options.</param>
         /// <remarks>
         /// Tries to load the implementation of the PDB writer from Microsoft.DiaSymReader.Native.{platform}.dll library first.
-        /// It searches for this library in the directory Microsoft.DiaSymReader.dll is loaded from, 
+        /// It searches for this library in the directory Microsoft.DiaSymReader.dll is loaded from,
         /// the application directory, the %WinDir%\System32 directory, and user directories in the DLL search path, in this order.
         /// If not found in the above locations and <see cref="SymUnmanagedWriterCreationOptions.UseAlternativeLoadPath"/> option is specified
         /// the directory specified by MICROSOFT_DIASYMREADER_NATIVE_ALT_LOAD_PATH environment variable is also searched.
-        /// If the Microsoft.DiaSymReader.Native.{platform}.dll library can't be found and <see cref="SymUnmanagedWriterCreationOptions.UseComRegistry"/> 
-        /// option is specified checks if the PDB reader is available from a globally registered COM object. This COM object is provided 
+        /// If the Microsoft.DiaSymReader.Native.{platform}.dll library can't be found and <see cref="SymUnmanagedWriterCreationOptions.UseComRegistry"/>
+        /// option is specified checks if the PDB reader is available from a globally registered COM object. This COM object is provided
         /// by .NET Framework and has limited functionality (features like determinism and source link are not supported).
         /// </remarks>
         /// <exception cref="ArgumentNullException"><paramref name="metadataProvider"/>is null.</exception>
         /// <exception cref="DllNotFoundException">The SymWriter implementation is not available or failed to load.</exception>
         /// <exception cref="SymUnmanagedWriterException">Error creating the PDB writer. See inner exception for root cause.</exception>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public static SymUnmanagedWriter CreateWriter(
             ISymWriterMetadataProvider metadataProvider,
             SymUnmanagedWriterCreationOptions options = SymUnmanagedWriterCreationOptions.Default)
diff --git a/src/Compilers/Core/Portable/Diagnostic/LocalizableResourceString.cs b/src/Compilers/Core/Portable/Diagnostic/LocalizableResourceString.cs
index 30c3615cca254..5727bd42e8c3f 100644
--- a/src/Compilers/Core/Portable/Diagnostic/LocalizableResourceString.cs
+++ b/src/Compilers/Core/Portable/Diagnostic/LocalizableResourceString.cs
@@ -21,11 +21,6 @@ public sealed class LocalizableResourceString : LocalizableString, IObjectWritab
         private readonly Type _resourceSource;
         private readonly string[] _formatArguments;
 
-        static LocalizableResourceString()
-        {
-            ObjectBinder.RegisterTypeReader(typeof(LocalizableResourceString), reader => new LocalizableResourceString(reader));
-        }
-
         /// <summary>
         /// Creates a localizable resource string with no formatting arguments.
         /// </summary>
@@ -72,29 +67,6 @@ public LocalizableResourceString(string nameOfLocalizableResource, ResourceManag
             _formatArguments = formatArguments;
         }
 
-        private LocalizableResourceString(ObjectReader reader)
-        {
-            _resourceSource = reader.ReadType();
-            _nameOfLocalizableResource = reader.ReadString();
-            _resourceManager = new ResourceManager(_resourceSource);
-
-            var length = reader.ReadInt32();
-            if (length == 0)
-            {
-                _formatArguments = Array.Empty<string>();
-            }
-            else
-            {
-                var argumentsBuilder = ArrayBuilder<string>.GetInstance(length);
-                for (int i = 0; i < length; i++)
-                {
-                    argumentsBuilder.Add(reader.ReadString());
-                }
-
-                _formatArguments = argumentsBuilder.ToArrayAndFree();
-            }
-        }
-
         bool IObjectWritable.ShouldReuseInSerialization => false;
 
         void IObjectWritable.WriteTo(ObjectWriter writer)
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Core.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Core.cs
index d5fd00ce05024..b7a7e92e0b1eb 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Core.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Core.cs
@@ -13,6 +13,7 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Runtime.Loader;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis
 {
@@ -28,7 +29,7 @@ internal enum AnalyzerLoadOption
         /// </summary>
         /// <remarks>
         /// While Windows supports this option it comes with a significant performance penalty due
-        /// to anti virus scans. It can have a load time of 300-500ms while loading from disk 
+        /// to anti virus scans. It can have a load time of 300-500ms while loading from disk
         /// is generally 1-2ms. Use this with caution on Windows.
         /// </remarks>
         LoadFromStream
@@ -97,6 +98,7 @@ internal void UnloadAll()
             }
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
         internal sealed class DirectoryLoadContext : AssemblyLoadContext
         {
             internal string Directory { get; }
@@ -136,7 +138,7 @@ public DirectoryLoadContext(string directory, AnalyzerAssemblyLoader loader, Ass
                 }
 
                 // Next prefer registered dependencies from other directories. Ideally this would not
-                // be necessary but msbuild target defaults have caused a number of customers to 
+                // be necessary but msbuild target defaults have caused a number of customers to
                 // fall into this path. See discussion here for where it comes up
                 // https://github.com/dotnet/roslyn/issues/56442
                 if (_loader.GetBestPath(assemblyName) is string bestRealPath)
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.cs
index 9d272f6dda833..a23568d9b9b5b 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.cs
@@ -34,8 +34,8 @@ internal abstract partial class AnalyzerAssemblyLoader : IAnalyzerAssemblyLoader
         private readonly Dictionary<string, (AssemblyName? AssemblyName, string RealAssemblyPath)?> _analyzerAssemblyInfoMap = new();
 
         /// <summary>
-        /// Maps analyzer dependency simple names to the set of original full paths it was loaded from. This _only_ 
-        /// tracks the paths provided to the analyzer as it's a place to look for indirect loads. 
+        /// Maps analyzer dependency simple names to the set of original full paths it was loaded from. This _only_
+        /// tracks the paths provided to the analyzer as it's a place to look for indirect loads.
         /// </summary>
         /// <remarks>
         /// Access must be guarded by <see cref="_guard"/>
@@ -53,8 +53,8 @@ internal abstract partial class AnalyzerAssemblyLoader : IAnalyzerAssemblyLoader
         private partial Assembly Load(AssemblyName assemblyName, string assemblyOriginalPath);
 
         /// <summary>
-        /// Determines if the <paramref name="candidateName"/> satisfies the request for 
-        /// <paramref name="requestedName"/>. This is partial'd out as each runtime has a different 
+        /// Determines if the <paramref name="candidateName"/> satisfies the request for
+        /// <paramref name="requestedName"/>. This is partial'd out as each runtime has a different
         /// definition of matching name.
         /// </summary>
         private partial bool IsMatch(AssemblyName requestedName, AssemblyName candidateName);
@@ -85,7 +85,7 @@ public void AddDependencyLocation(string fullPath)
                 }
 
                 // This type assumses the file system is static for the duration of the
-                // it's instance. Repeated calls to this method, even if the underlying 
+                // it's instance. Repeated calls to this method, even if the underlying
                 // file system contents, should reuse the results of the first call.
                 _ = _analyzerAssemblyInfoMap.TryAdd(fullPath, null);
             }
@@ -114,7 +114,7 @@ public Assembly LoadFromPath(string originalAnalyzerPath)
         }
 
         /// <summary>
-        /// Get the <see cref="AssemblyName"/> and the path it should be loaded from for the given original 
+        /// Get the <see cref="AssemblyName"/> and the path it should be loaded from for the given original
         /// analyzer path
         /// </summary>
         /// <remarks>
@@ -145,8 +145,8 @@ public Assembly LoadFromPath(string originalAnalyzerPath)
             }
             catch
             {
-                // The above can fail when the assembly doesn't exist because it's corrupted, 
-                // doesn't exist on disk, or is a native DLL. Those failures are handled when 
+                // The above can fail when the assembly doesn't exist because it's corrupted,
+                // doesn't exist on disk, or is a native DLL. Those failures are handled when
                 // the actual load is attempted. Just record the failure now.
                 assemblyName = null;
             }
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.cs
index 95b4e0484bf48..ffe4a9db35b06 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerFileReference.cs
@@ -23,11 +23,12 @@ namespace Microsoft.CodeAnalysis.Diagnostics
     /// Represents analyzers stored in an analyzer assembly file.
     /// </summary>
     /// <remarks>
-    /// Analyzer are read from the file, owned by the reference, and doesn't change 
+    /// Analyzer are read from the file, owned by the reference, and doesn't change
     /// since the reference is accessed until the reference object is garbage collected.
-    /// 
+    ///
     /// If you need to manage the lifetime of the analyzer reference (and the file stream) explicitly use <see cref="AnalyzerImageReference"/>.
     /// </remarks>
+    [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
     public sealed class AnalyzerFileReference : AnalyzerReference, IEquatable<AnalyzerReference>
     {
         private delegate IEnumerable<string> AttributeLanguagesFunc(PEModule module, CustomAttributeHandle attribute);
@@ -347,6 +348,7 @@ private static string GetFullyQualifiedTypeName(TypeDefinition typeDef, PEModule
             }
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
         private sealed class Extensions<TExtension>
             where TExtension : class
         {
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs
index 7e3a95ce87050..eaa91387f2f33 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs
@@ -14,6 +14,7 @@
 
 namespace Microsoft.CodeAnalysis
 {
+    [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
     internal sealed class DefaultAnalyzerAssemblyLoader : AnalyzerAssemblyLoader
     {
 #if NETCOREAPP
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/ShadowCopyAnalyzerAssemblyLoader.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/ShadowCopyAnalyzerAssemblyLoader.cs
index eae0e67a96a6b..d4cf1d1b97b59 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/ShadowCopyAnalyzerAssemblyLoader.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/ShadowCopyAnalyzerAssemblyLoader.cs
@@ -9,6 +9,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Roslyn.Utilities;
 
 #if NETCOREAPP
 using System.Runtime.Loader;
@@ -16,6 +17,7 @@
 
 namespace Microsoft.CodeAnalysis
 {
+    [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.AnalyzerReflectionLoadMessage)]
     internal sealed class ShadowCopyAnalyzerAssemblyLoader : AnalyzerAssemblyLoader
     {
         /// <summary>
diff --git a/src/Compilers/Core/Portable/FileSystemExtensions.cs b/src/Compilers/Core/Portable/FileSystemExtensions.cs
index 113971f6cbbb3..940821f765884 100644
--- a/src/Compilers/Core/Portable/FileSystemExtensions.cs
+++ b/src/Compilers/Core/Portable/FileSystemExtensions.cs
@@ -22,13 +22,14 @@ public static class FileSystemExtensions
         /// Also embedded in the output file.  Null to forego PDB generation.
         /// </param>
         /// <param name="xmlDocPath">Path of the file to which the compilation's XML documentation will be written.  Null to forego XML generation.</param>
-        /// <param name="win32ResourcesPath">Path of the file from which the compilation's Win32 resources will be read (in RES format).  
+        /// <param name="win32ResourcesPath">Path of the file from which the compilation's Win32 resources will be read (in RES format).
         /// Null to indicate that there are none.</param>
         /// <param name="manifestResources">List of the compilation's managed resources.  Null to indicate that there are none.</param>
         /// <param name="cancellationToken">To cancel the emit process.</param>
         /// <exception cref="ArgumentNullException">Compilation or path is null.</exception>
         /// <exception cref="ArgumentException">Path is empty or invalid.</exception>
         /// <exception cref="IOException">An error occurred while reading or writing a file.</exception>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public static EmitResult Emit(
             this Compilation compilation,
             string outputPath,
diff --git a/src/Compilers/Core/Portable/InternalUtilities/DynamicallyAccessedMembersAttribute.cs b/src/Compilers/Core/Portable/InternalUtilities/DynamicallyAccessedMembersAttribute.cs
new file mode 100644
index 0000000000000..9d3ce1d5ca4a3
--- /dev/null
+++ b/src/Compilers/Core/Portable/InternalUtilities/DynamicallyAccessedMembersAttribute.cs
@@ -0,0 +1,119 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NET5_0_OR_GREATER
+
+using System;
+
+namespace System.Diagnostics.CodeAnalysis;
+
+[AttributeUsage(
+    AttributeTargets.Field | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter |
+    AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Method |
+    AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct,
+    Inherited = false)]
+internal sealed class DynamicallyAccessedMembersAttribute : Attribute
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DynamicallyAccessedMembersAttribute"/> class
+    /// with the specified member types.
+    /// </summary>
+    /// <param name="memberTypes">The types of members dynamically accessed.</param>
+    public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
+    {
+        MemberTypes = memberTypes;
+    }
+
+    /// <summary>
+    /// Gets the <see cref="DynamicallyAccessedMemberTypes"/> which specifies the type
+    /// of members dynamically accessed.
+    /// </summary>
+    public DynamicallyAccessedMemberTypes MemberTypes { get; }
+}
+
+[Flags]
+internal enum DynamicallyAccessedMemberTypes
+{
+    /// <summary>
+    /// Specifies no members.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    /// Specifies the default, parameterless public constructor.
+    /// </summary>
+    PublicParameterlessConstructor = 0x0001,
+
+    /// <summary>
+    /// Specifies all public constructors.
+    /// </summary>
+    PublicConstructors = 0x0002 | PublicParameterlessConstructor,
+
+    /// <summary>
+    /// Specifies all non-public constructors.
+    /// </summary>
+    NonPublicConstructors = 0x0004,
+
+    /// <summary>
+    /// Specifies all public methods.
+    /// </summary>
+    PublicMethods = 0x0008,
+
+    /// <summary>
+    /// Specifies all non-public methods.
+    /// </summary>
+    NonPublicMethods = 0x0010,
+
+    /// <summary>
+    /// Specifies all public fields.
+    /// </summary>
+    PublicFields = 0x0020,
+
+    /// <summary>
+    /// Specifies all non-public fields.
+    /// </summary>
+    NonPublicFields = 0x0040,
+
+    /// <summary>
+    /// Specifies all public nested types.
+    /// </summary>
+    PublicNestedTypes = 0x0080,
+
+    /// <summary>
+    /// Specifies all non-public nested types.
+    /// </summary>
+    NonPublicNestedTypes = 0x0100,
+
+    /// <summary>
+    /// Specifies all public properties.
+    /// </summary>
+    PublicProperties = 0x0200,
+
+    /// <summary>
+    /// Specifies all non-public properties.
+    /// </summary>
+    NonPublicProperties = 0x0400,
+
+    /// <summary>
+    /// Specifies all public events.
+    /// </summary>
+    PublicEvents = 0x0800,
+
+    /// <summary>
+    /// Specifies all non-public events.
+    /// </summary>
+    NonPublicEvents = 0x1000,
+
+    /// <summary>
+    /// Specifies all interfaces implemented by the type.
+    /// </summary>
+    Interfaces = 0x2000,
+
+    /// <summary>
+    /// Specifies all members.
+    /// </summary>
+    All = ~None
+}
+
+#endif
\ No newline at end of file
diff --git a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
index 8ed1dbfbfca97..0a7e4b7954a1b 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/FatalError.cs
@@ -72,6 +72,7 @@ public static void OverwriteHandler(ErrorReporterHandler? value)
         /// This file is in linked into multiple layers, but we want to ensure that all layers have the same copy.
         /// This lets us copy the handler in this instance into the same in another instance.
         /// </remarks>
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.LoadsTypeByName)]
         public static void CopyHandlerTo(Assembly assembly)
         {
             var targetType = assembly.GetType(typeof(FatalError).FullName!, throwOnError: true)!;
diff --git a/src/Compilers/Core/Portable/InternalUtilities/ReflectionUtilities.cs b/src/Compilers/Core/Portable/InternalUtilities/ReflectionUtilities.cs
index 412b9250586cb..332d6159bcd48 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/ReflectionUtilities.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/ReflectionUtilities.cs
@@ -15,6 +15,7 @@ internal static class ReflectionUtilities
     {
         private static readonly Type Missing = typeof(void);
 
+        [RequiresUnreferencedCode(TrimWarningMessages.LoadsTypeByName)]
         public static Type? TryGetType(string assemblyQualifiedName)
         {
             try
@@ -28,6 +29,7 @@ internal static class ReflectionUtilities
             }
         }
 
+        [RequiresUnreferencedCode(TrimWarningMessages.LoadsTypeByName)]
         public static Type? TryGetType([NotNull] ref Type? lazyType, string assemblyQualifiedName)
         {
             if (lazyType == null)
@@ -40,8 +42,9 @@ internal static class ReflectionUtilities
 
         /// <summary>
         /// Find a <see cref="Type"/> instance by first probing the contract name and then the name as it
-        /// would exist in mscorlib.  This helps satisfy both the CoreCLR and Desktop scenarios. 
+        /// would exist in mscorlib.  This helps satisfy both the CoreCLR and Desktop scenarios.
         /// </summary>
+        [RequiresUnreferencedCode(TrimWarningMessages.LoadsTypeByName)]
         public static Type? GetTypeFromEither(string contractName, string desktopName)
         {
             var type = TryGetType(contractName);
@@ -54,6 +57,7 @@ internal static class ReflectionUtilities
             return type;
         }
 
+        [RequiresUnreferencedCode(TrimWarningMessages.LoadsTypeByName)]
         public static Type? GetTypeFromEither([NotNull] ref Type? lazyType, string contractName, string desktopName)
         {
             if (lazyType == null)
@@ -94,12 +98,16 @@ internal static class ReflectionUtilities
             return null;
         }
 
-        internal static MethodInfo? GetDeclaredMethod(this TypeInfo typeInfo, string name, params Type[] paramTypes)
+        internal static MethodInfo? GetDeclaredMethod(
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)]
+            this TypeInfo typeInfo, string name, params Type[] paramTypes)
         {
             return FindItem(typeInfo.GetDeclaredMethods(name), paramTypes);
         }
 
-        internal static ConstructorInfo? GetDeclaredConstructor(this TypeInfo typeInfo, params Type[] paramTypes)
+        internal static ConstructorInfo? GetDeclaredConstructor(
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)]
+            this TypeInfo typeInfo, params Type[] paramTypes)
         {
             return FindItem(typeInfo.DeclaredConstructors, paramTypes);
         }
diff --git a/src/Compilers/Core/Portable/InternalUtilities/RequiresUnreferencedCodeAttribute.cs b/src/Compilers/Core/Portable/InternalUtilities/RequiresUnreferencedCodeAttribute.cs
new file mode 100644
index 0000000000000..58326500fbd50
--- /dev/null
+++ b/src/Compilers/Core/Portable/InternalUtilities/RequiresUnreferencedCodeAttribute.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NET5_0_OR_GREATER
+namespace System.Diagnostics.CodeAnalysis;
+
+internal sealed class RequiresUnreferencedCodeAttribute : Attribute
+{
+    public string Message { get; }
+    public RequiresUnreferencedCodeAttribute(string message)
+    {
+        Message = message;
+    }
+}
+#endif
\ No newline at end of file
diff --git a/src/Compilers/Core/Portable/InternalUtilities/RoslynLazyInitializer.cs b/src/Compilers/Core/Portable/InternalUtilities/RoslynLazyInitializer.cs
index 1d1b08971540b..f6b0adfa6ea04 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/RoslynLazyInitializer.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/RoslynLazyInitializer.cs
@@ -11,7 +11,9 @@ namespace Roslyn.Utilities
     internal static class RoslynLazyInitializer
     {
         /// <inheritdoc cref="LazyInitializer.EnsureInitialized{T}(ref T)"/>
-        public static T EnsureInitialized<T>([NotNull] ref T? target) where T : class
+        public static T EnsureInitialized<
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
+        T>([NotNull] ref T? target) where T : class
             => LazyInitializer.EnsureInitialized<T>(ref target!);
 
         /// <inheritdoc cref="LazyInitializer.EnsureInitialized{T}(ref T, Func{T})"/>
@@ -19,7 +21,9 @@ public static T EnsureInitialized<T>([NotNull] ref T? target, Func<T> valueFacto
             => LazyInitializer.EnsureInitialized<T>(ref target!, valueFactory);
 
         /// <inheritdoc cref="LazyInitializer.EnsureInitialized{T}(ref T, ref bool, ref object)"/>
-        public static T EnsureInitialized<T>([NotNull] ref T? target, ref bool initialized, [NotNullIfNotNull(nameof(syncLock))] ref object? syncLock)
+        public static T EnsureInitialized<
+        [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
+        T>([NotNull] ref T? target, ref bool initialized, [NotNullIfNotNull(nameof(syncLock))] ref object? syncLock)
             => LazyInitializer.EnsureInitialized<T>(ref target!, ref initialized, ref syncLock);
 
         /// <inheritdoc cref="LazyInitializer.EnsureInitialized{T}(ref T, ref bool, ref object, Func{T})"/>
diff --git a/src/Compilers/Core/Portable/InternalUtilities/TrimWarningMessages.cs b/src/Compilers/Core/Portable/InternalUtilities/TrimWarningMessages.cs
new file mode 100644
index 0000000000000..15f4024398c13
--- /dev/null
+++ b/src/Compilers/Core/Portable/InternalUtilities/TrimWarningMessages.cs
@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Roslyn.Utilities;
+
+internal static class TrimWarningMessages
+{
+    internal const string AnalyzerReflectionLoadMessage = "Loading analyzers via reflection is not supported when trimming.";
+    internal const string NativePdbsNotSupported = "Native PDBs use built-in COM, which is not supported when trimming.";
+    internal const string LoadsTypeByName = "Loading types by name is not supported when trimming.";
+}
\ No newline at end of file
diff --git a/src/Compilers/Core/Portable/InternalUtilities/UICultureUtilities.cs b/src/Compilers/Core/Portable/InternalUtilities/UICultureUtilities.cs
index 43db5ec89535e..73635ca08fb13 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/UICultureUtilities.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/UICultureUtilities.cs
@@ -11,127 +11,23 @@ namespace Roslyn.Utilities
 {
     internal static class UICultureUtilities
     {
-        // TODO (DevDiv 1117307): Replace with CultureInfo.CurrentUICulture.set when available.
-        private const string currentUICultureName = "CurrentUICulture";
-        private static readonly Action<CultureInfo>? s_setCurrentUICulture;
-
-        private static bool TryGetCurrentUICultureSetter([NotNullWhen(returnValue: true)] out Action<CultureInfo>? setter)
-        {
-            const string cultureInfoTypeName = "System.Globalization.CultureInfo";
-            const string cultureInfoTypeNameGlobalization = cultureInfoTypeName + ", System.Globalization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";
-
-            try
-            {
-                var type = Type.GetType(cultureInfoTypeNameGlobalization) ?? typeof(object).GetTypeInfo().Assembly.GetType(cultureInfoTypeName);
-                if ((object?)type == null)
-                {
-                    setter = null;
-                    return false;
-                }
-
-                var currentUICultureSetter = type.GetTypeInfo().GetDeclaredProperty(currentUICultureName)?.SetMethod;
-                if ((object?)currentUICultureSetter == null || !currentUICultureSetter.IsStatic || currentUICultureSetter.ContainsGenericParameters || currentUICultureSetter.ReturnType != typeof(void))
-                {
-                    setter = null;
-                    return false;
-                }
-
-                var parameters = currentUICultureSetter.GetParameters();
-                if (parameters.Length != 1 || parameters[0].ParameterType != typeof(CultureInfo))
-                {
-                    setter = null;
-                    return false;
-                }
-
-                setter = (Action<CultureInfo>)currentUICultureSetter.CreateDelegate(typeof(Action<CultureInfo>));
-                return true;
-            }
-            catch
-            {
-                setter = null;
-                return false;
-            }
-        }
-
-        private static bool TryGetCurrentThreadUICultureSetter([NotNullWhen(returnValue: true)] out Action<CultureInfo>? setter)
-        {
-            const string threadTypeName = "System.Threading.Thread";
-            const string currentThreadName = "CurrentThread";
-
-            try
-            {
-                var type = typeof(object).GetTypeInfo().Assembly.GetType(threadTypeName);
-                if (type is null)
-                {
-                    setter = null;
-                    return false;
-                }
-
-                var typeInfo = type.GetTypeInfo();
-                var currentThreadGetter = typeInfo.GetDeclaredProperty(currentThreadName)?.GetMethod;
-                if ((object?)currentThreadGetter == null || !currentThreadGetter.IsStatic || currentThreadGetter.ContainsGenericParameters || currentThreadGetter.ReturnType != type || currentThreadGetter.GetParameters().Length != 0)
-                {
-                    setter = null;
-                    return false;
-                }
-
-                var currentUICultureSetter = typeInfo.GetDeclaredProperty(currentUICultureName)?.SetMethod;
-                if ((object?)currentUICultureSetter == null || currentUICultureSetter.IsStatic || currentUICultureSetter.ContainsGenericParameters || currentUICultureSetter.ReturnType != typeof(void))
-                {
-                    setter = null;
-                    return false;
-                }
-
-                var parameters = currentUICultureSetter.GetParameters();
-                if (parameters.Length != 1 || parameters[0].ParameterType != typeof(CultureInfo))
-                {
-                    setter = null;
-                    return false;
-                }
-
-                setter = culture =>
-                {
-                    currentUICultureSetter.Invoke(currentThreadGetter.Invoke(null, null), new[] { culture });
-                };
-                return true;
-            }
-            catch
-            {
-                setter = null;
-                return false;
-            }
-        }
-
-        static UICultureUtilities()
-        {
-            if (!TryGetCurrentUICultureSetter(out s_setCurrentUICulture) &&
-                !TryGetCurrentThreadUICultureSetter(out s_setCurrentUICulture))
-            {
-                s_setCurrentUICulture = null;
-            }
-        }
 
         public static Action WithCurrentUICulture(Action action)
         {
-            if (s_setCurrentUICulture == null)
-            {
-                return action;
-            }
-
             var savedCulture = CultureInfo.CurrentUICulture;
             return () =>
             {
                 var currentCulture = CultureInfo.CurrentUICulture;
                 if (currentCulture != savedCulture)
                 {
-                    s_setCurrentUICulture(savedCulture);
+                    CultureInfo.CurrentUICulture = savedCulture;
                     try
                     {
                         action();
                     }
                     finally
                     {
-                        s_setCurrentUICulture(currentCulture);
+                        CultureInfo.CurrentUICulture = currentCulture;
                     }
                 }
                 else
@@ -143,25 +39,20 @@ public static Action WithCurrentUICulture(Action action)
 
         public static Action<T> WithCurrentUICulture<T>(Action<T> action)
         {
-            if (s_setCurrentUICulture == null)
-            {
-                return action;
-            }
-
             var savedCulture = CultureInfo.CurrentUICulture;
             return param =>
             {
                 var currentCulture = CultureInfo.CurrentUICulture;
                 if (currentCulture != savedCulture)
                 {
-                    s_setCurrentUICulture(savedCulture);
+                    CultureInfo.CurrentUICulture = savedCulture;
                     try
                     {
                         action(param);
                     }
                     finally
                     {
-                        s_setCurrentUICulture(currentCulture);
+                        CultureInfo.CurrentUICulture = currentCulture;
                     }
                 }
                 else
@@ -173,25 +64,20 @@ public static Action<T> WithCurrentUICulture<T>(Action<T> action)
 
         public static Func<T> WithCurrentUICulture<T>(Func<T> func)
         {
-            if (s_setCurrentUICulture == null)
-            {
-                return func;
-            }
-
             var savedCulture = CultureInfo.CurrentUICulture;
             return () =>
             {
                 var currentCulture = CultureInfo.CurrentUICulture;
                 if (currentCulture != savedCulture)
                 {
-                    s_setCurrentUICulture(savedCulture);
+                    CultureInfo.CurrentUICulture = savedCulture;
                     try
                     {
                         return func();
                     }
                     finally
                     {
-                        s_setCurrentUICulture(currentCulture);
+                        CultureInfo.CurrentUICulture = currentCulture;
                     }
                 }
                 else
diff --git a/src/Compilers/Core/Portable/InternalUtilities/UnconditionalSuppressMessageAttribute.cs b/src/Compilers/Core/Portable/InternalUtilities/UnconditionalSuppressMessageAttribute.cs
new file mode 100644
index 0000000000000..110d092cb30f4
--- /dev/null
+++ b/src/Compilers/Core/Portable/InternalUtilities/UnconditionalSuppressMessageAttribute.cs
@@ -0,0 +1,90 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !NET5_0_OR_GREATER
+
+using System;
+
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// Suppresses reporting of a specific rule violation, allowing multiple suppressions on a
+/// single code artifact.
+/// </summary>
+/// <remarks>
+/// <see cref="UnconditionalSuppressMessageAttribute"/> is different than
+/// <see cref="SuppressMessageAttribute"/> in that it doesn't have a
+/// <see cref="ConditionalAttribute"/>. So it is always preserved in the compiled assembly.
+/// </remarks>
+[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+internal sealed class UnconditionalSuppressMessageAttribute : Attribute
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UnconditionalSuppressMessageAttribute"/>
+    /// class, specifying the category of the tool and the identifier for an analysis rule.
+    /// </summary>
+    /// <param name="category">The category for the attribute.</param>
+    /// <param name="checkId">The identifier of the analysis rule the attribute applies to.</param>
+    public UnconditionalSuppressMessageAttribute(string category, string checkId)
+    {
+        Category = category;
+        CheckId = checkId;
+    }
+
+    /// <summary>
+    /// Gets the category identifying the classification of the attribute.
+    /// </summary>
+    /// <remarks>
+    /// The <see cref="Category"/> property describes the tool or tool analysis category
+    /// for which a message suppression attribute applies.
+    /// </remarks>
+    public string Category { get; }
+
+    /// <summary>
+    /// Gets the identifier of the analysis tool rule to be suppressed.
+    /// </summary>
+    /// <remarks>
+    /// Concatenated together, the <see cref="Category"/> and <see cref="CheckId"/>
+    /// properties form a unique check identifier.
+    /// </remarks>
+    public string CheckId { get; }
+
+    /// <summary>
+    /// Gets or sets the scope of the code that is relevant for the attribute.
+    /// </summary>
+    /// <remarks>
+    /// The Scope property is an optional argument that specifies the metadata scope for which
+    /// the attribute is relevant.
+    /// </remarks>
+    public string? Scope { get; set; }
+
+    /// <summary>
+    /// Gets or sets a fully qualified path that represents the target of the attribute.
+    /// </summary>
+    /// <remarks>
+    /// The <see cref="Target"/> property is an optional argument identifying the analysis target
+    /// of the attribute. An example value is "System.IO.Stream.ctor():System.Void".
+    /// Because it is fully qualified, it can be long, particularly for targets such as parameters.
+    /// The analysis tool user interface should be capable of automatically formatting the parameter.
+    /// </remarks>
+    public string? Target { get; set; }
+
+    /// <summary>
+    /// Gets or sets an optional argument expanding on exclusion criteria.
+    /// </summary>
+    /// <remarks>
+    /// The <see cref="MessageId "/> property is an optional argument that specifies additional
+    /// exclusion where the literal metadata target is not sufficiently precise. For example,
+    /// the <see cref="UnconditionalSuppressMessageAttribute"/> cannot be applied within a method,
+    /// and it may be desirable to suppress a violation against a statement in the method that will
+    /// give a rule violation, but not against all statements in the method.
+    /// </remarks>
+    public string? MessageId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the justification for suppressing the code analysis message.
+    /// </summary>
+    public string? Justification { get; set; }
+}
+#endif
\ No newline at end of file
diff --git a/src/Compilers/Core/Portable/Microsoft.CodeAnalysis.csproj b/src/Compilers/Core/Portable/Microsoft.CodeAnalysis.csproj
index 25c19fff274fd..f4a60aaed8501 100644
--- a/src/Compilers/Core/Portable/Microsoft.CodeAnalysis.csproj
+++ b/src/Compilers/Core/Portable/Microsoft.CodeAnalysis.csproj
@@ -19,6 +19,12 @@
       Do not install this package manually, it will be added as a prerequisite by other packages that require it.
     </PackageDescription>
   </PropertyGroup>
+
+  <!-- Enable trimming/AOT compat -->
+  <PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net6.0'))">
+    <IsAotCompatible>true</IsAotCompatible>
+  </PropertyGroup>
+
   <ItemGroup>
     <None Include="Operations\OperationInterfaces.xml" />
   </ItemGroup>
diff --git a/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs b/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
index e2146c1a9d70d..1daff84ff9d23 100644
--- a/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
+++ b/src/Compilers/Core/Portable/NativePdbWriter/PdbWriter.cs
@@ -514,6 +514,7 @@ private void DefineScopeLocals(LocalScope currentScope, StandaloneSignatureHandl
             }
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public void SetMetadataEmitter(MetadataWriter metadataWriter)
         {
             // Do not look for COM registered diasymreader when determinism is needed as it doesn't support it.
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index 2c6c096f04f26..cb34e7efc577b 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -1688,6 +1688,7 @@ internal EntityHandle GetDefinitionHandle(IDefinition definition)
             };
         }
 
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         public void WriteMetadataAndIL(PdbWriter nativePdbWriterOpt, Stream metadataStream, Stream ilStream, Stream portablePdbStreamOpt, out MetadataSizes metadataSizes)
         {
             Debug.Assert(nativePdbWriterOpt == null ^ portablePdbStreamOpt == null);
diff --git a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
index aa657c2b15566..ef01bc1164f80 100644
--- a/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/PeWriter.cs
@@ -21,6 +21,7 @@
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.DiaSymReader;
+using Roslyn.Utilities;
 using static Microsoft.CodeAnalysis.SigningUtilities;
 using EmitContext = Microsoft.CodeAnalysis.Emit.EmitContext;
 
@@ -35,6 +36,7 @@ public PeWritingException(Exception inner)
 
     internal static class PeWriter
     {
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode(TrimWarningMessages.NativePdbsNotSupported)]
         internal static bool WritePeToStream(
             EmitContext context,
             CommonMessageProvider messageProvider,
@@ -206,8 +208,8 @@ internal static bool WritePeToStream(
 
                     if (!portablePdbContentHash.IsDefault)
                     {
-                        // Emit PDB Checksum entry for Portable and Embedded PDBs. The checksum is not as useful when the PDB is embedded, 
-                        // however it allows the client to efficiently validate a standalone Portable PDB that 
+                        // Emit PDB Checksum entry for Portable and Embedded PDBs. The checksum is not as useful when the PDB is embedded,
+                        // however it allows the client to efficiently validate a standalone Portable PDB that
                         // has been extracted from Embedded PDB and placed next to the PE file.
                         debugDirectoryBuilder.AddPdbChecksumEntry(context.Module.PdbChecksumAlgorithm.Name, portablePdbContentHash);
                     }
diff --git a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
index 9cc79e692db6f..b274d3e6e577f 100644
--- a/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
+++ b/src/Compilers/Core/Portable/Serialization/ObjectReader.cs
@@ -657,12 +657,6 @@ private double[] ReadFloat8ArrayElements(double[] array)
             return array;
         }
 
-        public Type ReadType()
-        {
-            _reader.ReadByte();
-            return Type.GetType(ReadString());
-        }
-
         private Type ReadTypeAfterTag()
             => _binderSnapshot.GetTypeFromId(this.ReadInt32());
 
diff --git a/src/ExpressionEvaluator/Core/Source/ResultProvider/Portable/Microsoft.CodeAnalysis.ResultProvider.csproj b/src/ExpressionEvaluator/Core/Source/ResultProvider/Portable/Microsoft.CodeAnalysis.ResultProvider.csproj
index 2577513d917e2..120f7986e9136 100644
--- a/src/ExpressionEvaluator/Core/Source/ResultProvider/Portable/Microsoft.CodeAnalysis.ResultProvider.csproj
+++ b/src/ExpressionEvaluator/Core/Source/ResultProvider/Portable/Microsoft.CodeAnalysis.ResultProvider.csproj
@@ -19,6 +19,9 @@
     <Compile Include="..\..\..\..\..\Compilers\Core\Portable\InternalUtilities\Debug.cs">
       <Link>Compiler\InternalUtilities\Debug.cs</Link>
     </Compile>
+    <Compile Include="..\..\..\..\..\Compilers\Core\Portable\InternalUtilities\DynamicallyAccessedMembersAttribute.cs">
+      <Link>Compiler\InternalUtilities\DynamicallyAccessedMembersAttribute.cs</Link>
+    </Compile>
     <Compile Include="..\..\..\..\..\Compilers\Core\Portable\InternalUtilities\FailFast.cs">
       <Link>Compiler\InternalUtilities\FailFast.cs</Link>
     </Compile>
@@ -37,6 +40,12 @@
     <Compile Include="..\..\..\..\..\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs">
       <Link>Compiler\InternalUtilities\ReflectionUtilities.cs</Link>
     </Compile>
+    <Compile Include="..\..\..\..\..\Compilers\Core\Portable\InternalUtilities\TrimWarningMessages.cs">
+      <Link>Compiler\InternalUtilities\TrimWarningMessages.cs</Link>
+    </Compile>
+    <Compile Include="..\..\..\..\..\Compilers\Core\Portable\InternalUtilities\RequiresUnreferencedCodeAttribute.cs">
+      <Link>Compiler\InternalUtilities\RequiresUnreferencedCodeAttribute.cs</Link>
+    </Compile>
     <Compile Include="..\..\..\..\..\Dependencies\PooledObjects\ObjectPool`1.cs">
       <Link>Compiler\InternalUtilities\ObjectPool`1.cs</Link>
     </Compile>
diff --git a/src/ExpressionEvaluator/Core/Test/ResultProvider/Microsoft.CodeAnalysis.ResultProvider.Utilities.csproj b/src/ExpressionEvaluator/Core/Test/ResultProvider/Microsoft.CodeAnalysis.ResultProvider.Utilities.csproj
index cf08b47b2c979..1465bdaa01b3c 100644
--- a/src/ExpressionEvaluator/Core/Test/ResultProvider/Microsoft.CodeAnalysis.ResultProvider.Utilities.csproj
+++ b/src/ExpressionEvaluator/Core/Test/ResultProvider/Microsoft.CodeAnalysis.ResultProvider.Utilities.csproj
@@ -30,6 +30,9 @@
     <Compile Include="..\..\..\..\Compilers\Core\Portable\InternalUtilities\Debug.cs">
       <Link>Compiler\InternalUtilities\Debug.cs</Link>
     </Compile>
+    <Compile Include="..\..\..\..\Compilers\Core\Portable\InternalUtilities\DynamicallyAccessedMembersAttribute.cs">
+      <Link>Compiler\InternalUtilities\DynamicallyAccessedMembersAttribute.cs</Link>
+    </Compile>
     <Compile Include="..\..\..\..\Compilers\Core\Portable\InternalUtilities\FailFast.cs">
       <Link>Compiler\InternalUtilities\FailFast.cs</Link>
     </Compile>
@@ -48,6 +51,12 @@
     <Compile Include="..\..\..\..\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs">
       <Link>Compiler\InternalUtilities\ReflectionUtilities.cs</Link>
     </Compile>
+    <Compile Include="..\..\..\..\Compilers\Core\Portable\InternalUtilities\RequiresUnreferencedCodeAttribute.cs">
+      <Link>Compiler\InternalUtilities\RequiresUnreferencedCodeAttribute.cs</Link>
+    </Compile>
+    <Compile Include="..\..\..\..\Compilers\Core\Portable\InternalUtilities\TrimWarningMessages.cs">
+      <Link>Compiler\InternalUtilities\TrimWarningMessages.cs</Link>
+    </Compile>
     <Compile Include="..\..\..\..\Dependencies\PooledObjects\ObjectPool`1.cs">
       <Link>Compiler\InternalUtilities\ObjectPool`1.cs</Link>
     </Compile>
diff --git a/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj b/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
index a17384a557b5d..1fa8d5113abcd 100644
--- a/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
+++ b/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
@@ -49,6 +49,8 @@
     <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs" Link="Utilities\SemaphoreSlimExtensions.cs" />
     <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\ExceptionUtilities.cs" Link="Utilities\ExceptionUtilities.cs" />
     <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\FailFast.cs" Link="Utilities\FailFast.cs" />
+    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\RequiresUnreferencedCodeAttribute.cs" Link="Utilities\RequiresUnreferencedCodeAttribute.cs" />
+    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\TrimWarningMessages.cs" Link="Utilities\TrimWarningMessages.cs" />
     <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\FatalError.cs" Link="Utilities\FatalError.cs" />
     <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\FileNameUtilities.cs" Link="Utilities\FileNameUtilities.cs" />
     <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\PlatformInformation.cs" Link="Utilities\PlatformInformation.cs" />
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
index 92505d93d0e36..74fe4691436a4 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
@@ -107,6 +107,9 @@
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\DocumentationCommentXmlNames.cs">
       <Link>InternalUtilities\DocumentationCommentXmlNames.cs</Link>
     </Compile>
+    <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\DynamicallyAccessedMembersAttribute.cs">
+      <Link>InternalUtilities\DynamicallyAccessedMembersAttribute.cs</Link>
+    </Compile>
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\EncodingExtensions.cs">
       <Link>InternalUtilities\EncodingExtensions.cs</Link>
     </Compile>
@@ -183,6 +186,12 @@
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs">
       <Link>InternalUtilities\ReflectionUtilities.cs</Link>
     </Compile>
+    <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\TrimWarningMessages.cs">
+      <Link>InternalUtilities\ReflectionUtilities.cs</Link>
+    </Compile>
+    <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\RequiresUnreferencedCodeAttribute.cs">
+      <Link>InternalUtilities\RequiresUnreferencedCodeAttribute.cs</Link>
+    </Compile>
     <Compile Include="$(MSBuildThisFileDirectory)..\..\..\..\Compilers\Core\Portable\InternalUtilities\UnicodeCharacterUtilities.cs">
       <Link>InternalUtilities\UnicodeCharacterUtilities.cs</Link>
     </Compile>