[ApiDiff] Allow passing diagnostic options to all Compat places that use CSharpCompilationOptions

src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI/CSharpAssemblyDocumentGenerator.cs

@@ -35,6 +35,7 @@ public sealed class CSharpAssemblyDocumentGenerator
     private readonly IEnumerable<MetadataReference>? _metadataReferences;
     private readonly bool _addPartialModifier;
     private readonly bool _hideImplicitDefaultConstructors;
+    private readonly CSharpCompilationOptions _compilationOptions;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="CSharpAssemblyDocumentGenerator"/> class.
@@ -46,6 +47,7 @@ public sealed class CSharpAssemblyDocumentGenerator
     /// <param name="exceptionMessage">The optional exception message to use.</param>
     /// <param name="includeAssemblyAttributes">Whether to include assembly attributes or not.</param>
     /// <param name="metadataReferences">The metadata references to use. The default value is <see langword="null"/>.</param>
+    /// <param name="diagnosticOptions">The optional diagnostic options to use. The default value is <see langword="null"/>.</param>
     /// <param name="addPartialModifier">Whether to add the partial modifier or not. The default value is <see langword="true"/>.</param>
     /// <param name="hideImplicitDefaultConstructors">Whether to hide implicit default constructors or not. The default value is <see langword="true"/>.</param>
     public CSharpAssemblyDocumentGenerator(ILog log,
@@ -55,6 +57,7 @@ public CSharpAssemblyDocumentGenerator(ILog log,
                                  string? exceptionMessage,
                                  bool includeAssemblyAttributes,
                                  IEnumerable<MetadataReference>? metadataReferences = null,
+                                 IEnumerable<KeyValuePair<string, ReportDiagnostic>>? diagnosticOptions = null,
                                  bool addPartialModifier = true,
                                  bool hideImplicitDefaultConstructors = true)
     {
@@ -69,6 +72,11 @@ public CSharpAssemblyDocumentGenerator(ILog log,
         _metadataReferences = metadataReferences;
         _addPartialModifier = addPartialModifier;
         _hideImplicitDefaultConstructors = hideImplicitDefaultConstructors;
+
+        _compilationOptions = new CSharpCompilationOptions(
+            OutputKind.DynamicallyLinkedLibrary,
+            nullableContextOptions: NullableContextOptions.Enable,
+            specificDiagnosticOptions: diagnosticOptions);
     }
 
     /// <summary>
@@ -78,11 +86,9 @@ public CSharpAssemblyDocumentGenerator(ILog log,
     /// <returns>The source code document instance of the specified assembly symbol.</returns>
     public Document GetDocumentForAssembly(IAssemblySymbol assemblySymbol)
     {
-        CSharpCompilationOptions compilationOptions = new(OutputKind.DynamicallyLinkedLibrary,
-               nullableContextOptions: NullableContextOptions.Enable);
         Project project = _adhocWorkspace.AddProject(ProjectInfo.Create(
             ProjectId.CreateNewId(), VersionStamp.Create(), assemblySymbol.Name, assemblySymbol.Name, LanguageNames.CSharp,
-            compilationOptions: compilationOptions));
+            compilationOptions: _compilationOptions));
         project = project.AddMetadataReferences(_metadataReferences ?? _loader.MetadataReferences);
 
         IEnumerable<INamespaceSymbol> namespaceSymbols = EnumerateNamespaces(assemblySymbol).Where(_symbolFilter.Include);

src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI/CSharpFileBuilder.cs

@@ -33,7 +33,7 @@ public CSharpFileBuilder(ILog log,
         {
             _textWriter = textWriter;
             _header = header;
-            _docGenerator = new CSharpAssemblyDocumentGenerator(log, loader, symbolFilter, attributeDataSymbolFilter, exceptionMessage, includeAssemblyAttributes, metadataReferences, addPartialModifier);
+            _docGenerator = new CSharpAssemblyDocumentGenerator(log, loader, symbolFilter, attributeDataSymbolFilter, exceptionMessage, includeAssemblyAttributes, metadataReferences, addPartialModifier: addPartialModifier);
         }
 
         /// <inheritdoc />

src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI/GenAPIApp.cs

@@ -35,7 +35,7 @@ public static void Run(ILog log,
                 log,
                 assembliesPaths,
                 assemblyReferencesPaths,
-                respectInternals);
+                respectInternals: respectInternals);
 
             Run(log,
                 loader,

src/Compatibility/Microsoft.DotNet.ApiSymbolExtensions/AssemblySymbolLoader.cs

@@ -57,17 +57,19 @@ public class AssemblySymbolLoader : IAssemblySymbolLoader
         /// <param name="log">The logger instance to use for message logging.</param>
         /// <param name="assembliesPaths">A collection of paths where the assembly DLLs should be searched.</param>
         /// <param name="assemblyReferencesPaths">An optional collection of paths where the assembly references should be searched.</param>
+        /// <param name="diagnosticOptions">An optional list of diagnostic options to use when compiling the loaded assemblies.</param>
         /// <param name="respectInternals">Whether to include internal symbols or not.</param>
         /// <returns>A tuple containing an assembly symbol loader and its corresponding dictionary of assembly symbols.</returns>
-        public static (AssemblySymbolLoader, Dictionary<string, IAssemblySymbol>) CreateFromFiles(ILog log, string[] assembliesPaths, string[]? assemblyReferencesPaths, bool respectInternals = false)
+        public static (AssemblySymbolLoader, Dictionary<string, IAssemblySymbol>) CreateFromFiles(ILog log, string[] assembliesPaths, string[]? assemblyReferencesPaths, IEnumerable<KeyValuePair<string, ReportDiagnostic>>? diagnosticOptions = null, bool respectInternals = false)
         {
             if (assembliesPaths.Length == 0)
             {
-                return (new AssemblySymbolLoader(log, resolveAssemblyReferences: true, includeInternalSymbols: respectInternals), new Dictionary<string, IAssemblySymbol>());
+                return (new AssemblySymbolLoader(log, diagnosticOptions, resolveAssemblyReferences: true, includeInternalSymbols: respectInternals),
+                        new Dictionary<string, IAssemblySymbol>());
             }
 
             bool atLeastOneReferencePath = assemblyReferencesPaths?.Count() > 0;
-            AssemblySymbolLoader loader = new(log, resolveAssemblyReferences: atLeastOneReferencePath, respectInternals);
+            AssemblySymbolLoader loader = new(log, diagnosticOptions, resolveAssemblyReferences: atLeastOneReferencePath, includeInternalSymbols: respectInternals);
             if (atLeastOneReferencePath)
             {
                 loader.AddReferenceSearchPaths(assemblyReferencesPaths!);
@@ -97,14 +99,18 @@ public static (AssemblySymbolLoader, Dictionary<string, IAssemblySymbol>) Create
         /// Creates a new instance of the <see cref="AssemblySymbolLoader"/> class.
         /// </summary>
         /// <param name="log">A logger instance for logging message.</param>
+        /// <param name="diagnosticOptions">An optional list of diagnostic options to use when compiling the loaded assemblies.</param>
         /// <param name="resolveAssemblyReferences">True to attempt to load references for loaded assemblies from the locations specified with <see cref="AddReferenceSearchPaths(string[])"/>. Default is false.</param>
         /// <param name="includeInternalSymbols">True to include all internal metadata for assemblies loaded. Default is false which only includes public and some internal metadata. <seealso cref="MetadataImportOptions"/></param>
-        public AssemblySymbolLoader(ILog log, bool resolveAssemblyReferences = false, bool includeInternalSymbols = false)
+        public AssemblySymbolLoader(ILog log, IEnumerable<KeyValuePair<string, ReportDiagnostic>>? diagnosticOptions = null, bool resolveAssemblyReferences = false, bool includeInternalSymbols = false)
         {
             _log = log;
             _loadedAssemblies = [];
-            CSharpCompilationOptions compilationOptions = new(OutputKind.DynamicallyLinkedLibrary, nullableContextOptions: NullableContextOptions.Enable,
-                metadataImportOptions: includeInternalSymbols ? MetadataImportOptions.Internal : MetadataImportOptions.Public);
+            CSharpCompilationOptions compilationOptions = new(
+                OutputKind.DynamicallyLinkedLibrary,
+                nullableContextOptions: NullableContextOptions.Enable,
+                metadataImportOptions: includeInternalSymbols ? MetadataImportOptions.Internal : MetadataImportOptions.Public,
+                specificDiagnosticOptions: diagnosticOptions);
             _cSharpCompilation = CSharpCompilation.Create($"AssemblyLoader_{DateTime.Now:MM_dd_yy_HH_mm_ss_FFF}", options: compilationOptions);
             _resolveReferences = resolveAssemblyReferences;
         }

src/Compatibility/Microsoft.DotNet.ApiSymbolExtensions/AssemblySymbolLoaderFactory.cs

@@ -14,6 +14,6 @@ public sealed class AssemblySymbolLoaderFactory(ILog log, bool includeInternalSy
     {
         /// <inheritdoc />
         public IAssemblySymbolLoader Create(bool shouldResolveReferences) =>
-            new AssemblySymbolLoader(log, shouldResolveReferences, includeInternalSymbols);
+            new AssemblySymbolLoader(log, resolveAssemblyReferences: shouldResolveReferences, includeInternalSymbols: includeInternalSymbols);
     }
 }

test/Microsoft.DotNet.ApiSymbolExtensions.Tests/SymbolFactory.cs

@@ -31,12 +31,13 @@ public static string EmitAssemblyFromSyntax(string syntax,
         }
 
         public static Stream EmitAssemblyStreamFromSyntax(string syntax,
+            IEnumerable<KeyValuePair<string, ReportDiagnostic>> diagnosticOptions = null,
             bool enableNullable = false,
             byte[] publicKey = null,
             [CallerMemberName] string assemblyName = "",
             bool allowUnsafe = false)
         {
-            CSharpCompilation compilation = CreateCSharpCompilationFromSyntax(syntax, assemblyName, enableNullable, publicKey, allowUnsafe);
+            CSharpCompilation compilation = CreateCSharpCompilationFromSyntax(syntax, assemblyName, enableNullable, publicKey, allowUnsafe, diagnosticOptions);
 
             Assert.Empty(compilation.GetDiagnostics());
 
@@ -76,9 +77,9 @@ public static IAssemblySymbol GetAssemblyFromSyntaxWithReferences(string syntax,
             return compilation.Assembly;
         }
 
-        private static CSharpCompilation CreateCSharpCompilationFromSyntax(string syntax, string name, bool enableNullable, byte[] publicKey, bool allowUnsafe)
+        private static CSharpCompilation CreateCSharpCompilationFromSyntax(string syntax, string name, bool enableNullable, byte[] publicKey, bool allowUnsafe, IEnumerable<KeyValuePair<string, ReportDiagnostic>> diagnosticOptions = null)
         {
-            CSharpCompilation compilation = CreateCSharpCompilation(name, enableNullable, publicKey, allowUnsafe);
+            CSharpCompilation compilation = CreateCSharpCompilation(name, enableNullable, publicKey, allowUnsafe, diagnosticOptions);
             return compilation.AddSyntaxTrees(GetSyntaxTree(syntax));
         }
 
@@ -94,15 +95,15 @@ private static SyntaxTree GetSyntaxTree(string syntax)
             return CSharpSyntaxTree.ParseText(syntax, ParseOptions);
         }
 
-        private static CSharpCompilation CreateCSharpCompilation(string name, bool enableNullable, byte[] publicKey, bool allowUnsafe)
+        private static CSharpCompilation CreateCSharpCompilation(string name, bool enableNullable, byte[] publicKey, bool allowUnsafe, IEnumerable<KeyValuePair<string, ReportDiagnostic>> diagnosticOptions = null)
         {
             bool publicSign = publicKey != null ? true : false;
             var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary,
                                                                   publicSign: publicSign,
                                                                   cryptoPublicKey: publicSign ? publicKey.ToImmutableArray() : default,
                                                                   nullableContextOptions: enableNullable ? NullableContextOptions.Enable : NullableContextOptions.Disable,
                                                                   allowUnsafe: allowUnsafe,
-                                                                  specificDiagnosticOptions: DiagnosticOptions);
+                                                                  specificDiagnosticOptions: diagnosticOptions ?? DiagnosticOptions);
 
             return CSharpCompilation.Create(name, options: compilationOptions, references: DefaultReferences);
         }

test/Microsoft.DotNet.GenAPI.Tests/CSharpFileBuilderTests.cs

@@ -9,7 +9,6 @@
 using Microsoft.DotNet.ApiSymbolExtensions;
 using Microsoft.DotNet.ApiSymbolExtensions.Filtering;
 using Microsoft.DotNet.ApiSymbolExtensions.Logging;
-using Microsoft.DotNet.ApiSymbolExtensions.Tests;
 using Moq;
 
 namespace Microsoft.DotNet.GenAPI.Tests
@@ -40,7 +39,7 @@ private void RunTest(string original,
             Mock<ILog> log = new();
 
             (IAssemblySymbolLoader loader, Dictionary<string, IAssemblySymbol> assemblySymbols) = TestAssemblyLoaderFactory
-                .CreateFromTexts(log.Object, assemblyTexts: [(assemblyName, original)], respectInternals: includeInternalSymbols, allowUnsafe);
+                .CreateFromTexts(log.Object, assemblyTexts: [(assemblyName, original)], respectInternals: includeInternalSymbols, allowUnsafe: allowUnsafe);
 
             ISymbolFilter symbolFilter = SymbolFilterFactory.GetFilterFromList([], null, includeInternalSymbols, includeEffectivelyPrivateSymbols, includeExplicitInterfaceImplementationSymbols);
             ISymbolFilter attributeDataSymbolFilter = SymbolFilterFactory.GetFilterFromList(excludedAttributeList, null, includeInternalSymbols, includeEffectivelyPrivateSymbols, includeExplicitInterfaceImplementationSymbols);

test/Microsoft.DotNet.GenAPI.Tests/TestAssemblyLoaderFactory.cs

@@ -11,21 +11,22 @@ namespace Microsoft.DotNet.GenAPI.Tests;
 
 public class TestAssemblyLoaderFactory
 {
-    public static (IAssemblySymbolLoader, Dictionary<string, IAssemblySymbol>) CreateFromTexts(ILog log, (string, string)[] assemblyTexts, bool respectInternals = false, bool allowUnsafe = false)
+    public static (IAssemblySymbolLoader, Dictionary<string, IAssemblySymbol>) CreateFromTexts(ILog log, (string, string)[] assemblyTexts, IEnumerable<KeyValuePair<string, ReportDiagnostic>>? diagnosticOptions = null, bool respectInternals = false, bool allowUnsafe = false)
     {
         if (assemblyTexts.Length == 0)
         {
-            return (new AssemblySymbolLoader(log, resolveAssemblyReferences: true, includeInternalSymbols: respectInternals), new Dictionary<string, IAssemblySymbol>());
+            return (new AssemblySymbolLoader(log, diagnosticOptions, resolveAssemblyReferences: true, includeInternalSymbols: respectInternals),
+                    new Dictionary<string, IAssemblySymbol>());
         }
 
-        AssemblySymbolLoader loader = new(log, resolveAssemblyReferences: true, includeInternalSymbols: respectInternals);
+        AssemblySymbolLoader loader = new(log, diagnosticOptions, resolveAssemblyReferences: true, includeInternalSymbols: respectInternals);
         loader.AddReferenceSearchPaths(typeof(object).Assembly!.Location!);
         loader.AddReferenceSearchPaths(typeof(DynamicAttribute).Assembly!.Location!);
 
         Dictionary<string, IAssemblySymbol> assemblySymbols = new();
         foreach ((string assemblyName, string assemblyText) in assemblyTexts)
         {
-            using Stream assemblyStream = SymbolFactory.EmitAssemblyStreamFromSyntax(assemblyText, enableNullable: true, allowUnsafe: allowUnsafe, assemblyName: assemblyName);
+            using Stream assemblyStream = SymbolFactory.EmitAssemblyStreamFromSyntax(assemblyText, diagnosticOptions, enableNullable: true, allowUnsafe: allowUnsafe, assemblyName: assemblyName);
             if (loader.LoadAssembly(assemblyName, assemblyStream) is IAssemblySymbol assemblySymbol)
             {
                 assemblySymbols.Add(assemblyName, assemblySymbol);