Allow passing the diagnostic options to all Compatibility places using CSharpCompilationOptions.

Author: carlossanlop

src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI.Task/GenAPITask.cs

@@ -72,7 +72,7 @@ protected override void ExecuteCore()
                 log,
                 assembliesPaths: Assemblies,
                 assemblyReferencesPaths: AssemblyReferences,
-                RespectInternals);
+                respectInternals: RespectInternals);
 
             GenAPIApp.Run(log,
                           loader,

src/Compatibility/GenAPI/Microsoft.DotNet.GenAPI.Tool/Program.cs

@@ -110,7 +110,7 @@ static int Main(string[] args)
                     log,
                     assembliesPaths: assemblies,
                     assemblyReferencesPaths: parseResult.GetValue(assemblyReferencesOption),
-                    respectInternals);
+                    respectInternals: respectInternals);
 
                 GenAPIApp.Run(log,
                     loader,

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,
+                                 Dictionary<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,16 @@ 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));
+        ProjectInfo projectInfo = ProjectInfo.Create(
+            ProjectId.CreateNewId(),
+            VersionStamp.Create(),
+            assemblySymbol.Name,
+            assemblySymbol.Name,
+            LanguageNames.CSharp,
+            compilationOptions: _compilationOptions);
+
+        Project project = _adhocWorkspace.AddProject(projectInfo);
+
         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,14 @@ 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/Microsoft.DotNet.ApiSymbolExtensions/AssemblySymbolLoader.cs

@@ -57,17 +57,28 @@ 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 dictionary of specific 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, Dictionary<string, ReportDiagnostic>? diagnosticOptions = null, bool respectInternals = false)
         {
+            AssemblySymbolLoader loader;
             if (assembliesPaths.Length == 0)
             {
-                return (new AssemblySymbolLoader(log, resolveAssemblyReferences: true, includeInternalSymbols: respectInternals), new Dictionary<string, IAssemblySymbol>());
+                loader = new AssemblySymbolLoader(log,
+                    diagnosticOptions,
+                    resolveAssemblyReferences: true,
+                    includeInternalSymbols: respectInternals);
+
+                return (loader, new Dictionary<string, IAssemblySymbol>());
             }
 
             bool atLeastOneReferencePath = assemblyReferencesPaths?.Count() > 0;
-            AssemblySymbolLoader loader = new(log, resolveAssemblyReferences: atLeastOneReferencePath, respectInternals);
+            loader = new AssemblySymbolLoader(log,
+                diagnosticOptions,
+                resolveAssemblyReferences: atLeastOneReferencePath,
+                includeInternalSymbols: respectInternals);
+
             if (atLeastOneReferencePath)
             {
                 loader.AddReferenceSearchPaths(assemblyReferencesPaths!);
@@ -97,14 +108,19 @@ 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 dictionary of specific 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, Dictionary<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;
         }
@@ -160,6 +176,29 @@ public void AddReferenceSearchPaths(params string[] paths)
             return assemblySymbols;
         }
 
+        /// <inheritdoc />
+        private IDictionary<string, IAssemblySymbol> LoadAssembliesAsDictionary(params string[] paths)
+        {
+            // First resolve all assemblies that are passed in and create metadata references out of them.
+            // Reference assemblies of the passed in assemblies that themselves are passed in, will be skipped to be resolved,
+            // as they are resolved as part of the loop below.
+            ImmutableHashSet<string> fileNames = paths.Select(path => Path.GetFileName(path)).ToImmutableHashSet();
+            List<MetadataReference> assembliesToReturn = LoadFromPaths(paths, fileNames);
+
+            // Create IAssemblySymbols out of the MetadataReferences.
+            // Doing this after resolving references to make sure that references are available.
+            Dictionary<string, IAssemblySymbol> assemblySymbols = [];
+            foreach (MetadataReference metadataReference in assembliesToReturn)
+            {
+                if (_cSharpCompilation.GetAssemblyOrModuleSymbol(metadataReference) is IAssemblySymbol assemblySymbol)
+                {
+                    assemblySymbols.Add(assemblySymbol.Name, assemblySymbol);
+                }
+            }
+
+            return assemblySymbols;
+        }
+
         /// <inheritdoc />
         public IReadOnlyList<IAssemblySymbol?> LoadAssembliesFromArchive(string archivePath, IReadOnlyList<string> relativePaths)
         {

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

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.CodeAnalysis;
 using Microsoft.DotNet.ApiSymbolExtensions.Logging;
 
 namespace Microsoft.DotNet.ApiSymbolExtensions
@@ -14,6 +15,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);
     }
 }

src/Compatibility/Microsoft.DotNet.ApiSymbolExtensions/Filtering/CompositeSymbolFilter.cs

@@ -14,7 +14,114 @@ public sealed class CompositeSymbolFilter(params IEnumerable<ISymbolFilter> filt
         /// <summary>
         /// List on inner filters.
         /// </summary>
-        public List<ISymbolFilter> Filters { get; } = new(filters);
+        public List<ISymbolFilter> Filters { get; } = [.. filters];
+
+        /// <summary>
+        /// Creates a composite filter to exclude APIs using the DocIDs provided in the specifed file paths.
+        /// </summary>
+        /// <param name="apiExclusionFilePaths">A collection of paths where the exclusion files should be searched.</param>
+        /// <param name="respectInternals">Whether to include internal symbols or not.</param>
+        /// <param name="includeEffectivelyPrivateSymbols">Whether to include effectively private symbols or not.</param>
+        /// <param name="includeExplicitInterfaceImplementationSymbols">Whether to include explicit interface implementation symbols or not.</param>
+        /// <returns>An instance of the symbol filter.</returns>
+        public static ISymbolFilter GetSymbolFilterFromFiles(string[]? apiExclusionFilePaths,
+                                                                     bool respectInternals = false,
+                                                                     bool includeEffectivelyPrivateSymbols = true,
+                                                                     bool includeExplicitInterfaceImplementationSymbols = true)
+        {
+            DocIdSymbolFilter? docIdSymbolFilter =
+                apiExclusionFilePaths?.Count() > 0 ?
+                DocIdSymbolFilter.CreateFromFiles(apiExclusionFilePaths) : null;
+
+            return GetCompositeSymbolFilter(docIdSymbolFilter, respectInternals, includeEffectivelyPrivateSymbols, includeExplicitInterfaceImplementationSymbols, withImplicitSymbolFilter: true);
+        }
+
+        /// <summary>
+        /// Creates a composite filter to exclude APIs using the DocIDs provided in the specifed list.
+        /// </summary>
+        /// <param name="apiExclusionList">A collection of exclusion list.</param>
+        /// <param name="respectInternals">Whether to include internal symbols or not.</param>
+        /// <param name="includeEffectivelyPrivateSymbols">Whether to include effectively private symbols or not.</param>
+        /// <param name="includeExplicitInterfaceImplementationSymbols">Whether to include explicit interface implementation symbols or not.</param>
+        /// <returns>An instance of the symbol filter.</returns>
+        public static ISymbolFilter GetSymbolFilterFromList(string[]? apiExclusionList,
+                                                                    bool respectInternals = false,
+                                                                    bool includeEffectivelyPrivateSymbols = true,
+                                                                    bool includeExplicitInterfaceImplementationSymbols = true)
+        {
+            DocIdSymbolFilter? docIdSymbolFilter =
+                apiExclusionList?.Count() > 0 ?
+                DocIdSymbolFilter.CreateFromDocIDs(apiExclusionList) : null;
+
+            return GetCompositeSymbolFilter(docIdSymbolFilter, respectInternals, includeEffectivelyPrivateSymbols, includeExplicitInterfaceImplementationSymbols, withImplicitSymbolFilter: true);
+        }
+
+        /// <summary>
+        /// Creates an composite filter to exclude attributes using the DocID provided in the specified file paths.
+        /// </summary>
+        /// <param name="attributeExclusionFilePaths">A collection of paths where the exclusion files should be searched.</param>
+        /// <param name="respectInternals">Whether to include internal symbols or not.</param>
+        /// <param name="includeEffectivelyPrivateSymbols">Whether to include effectively private symbols or not.</param>
+        /// <param name="includeExplicitInterfaceImplementationSymbols">Whether to include explicit interface implementation symbols or not.</param>
+        /// <returns>An instance of the attribute filter.</returns>
+        public static ISymbolFilter GetAttributeFilterFromPaths(string[]? attributeExclusionFilePaths,
+                                                                        bool respectInternals = false,
+                                                                        bool includeEffectivelyPrivateSymbols = true,
+                                                                        bool includeExplicitInterfaceImplementationSymbols = true)
+        {
+            DocIdSymbolFilter? docIdSymbolFilter =
+                attributeExclusionFilePaths?.Count() > 0 ?
+                DocIdSymbolFilter.CreateFromFiles(attributeExclusionFilePaths) : null;
+
+            return GetCompositeSymbolFilter(docIdSymbolFilter, respectInternals, includeEffectivelyPrivateSymbols, includeExplicitInterfaceImplementationSymbols, withImplicitSymbolFilter: false);
+        }
+
+        /// <summary>
+        /// Creates an composite filter to exclude attributes using the DocID provided in the specified list.
+        /// </summary>
+        /// <param name="attributeExclusionList">A collection of exclusion list.</param>
+        /// <param name="respectInternals">Whether to include internal symbols or not.</param>
+        /// <param name="includeEffectivelyPrivateSymbols">Whether to include effectively private symbols or not.</param>
+        /// <param name="includeExplicitInterfaceImplementationSymbols">Whether to include explicit interface implementation symbols or not.</param>
+        /// <returns>An instance of the attribute filter.</returns>
+        public static ISymbolFilter GetAttributeFilterFromList(string[]? attributeExclusionList,
+                                                                       bool respectInternals = false,
+                                                                       bool includeEffectivelyPrivateSymbols = true,
+                                                                       bool includeExplicitInterfaceImplementationSymbols = true)
+        {
+            DocIdSymbolFilter? docIdSymbolFilter =
+                attributeExclusionList?.Count() > 0 ?
+                DocIdSymbolFilter.CreateFromDocIDs(attributeExclusionList) : null;
+
+            return GetCompositeSymbolFilter(docIdSymbolFilter, respectInternals, includeEffectivelyPrivateSymbols, includeExplicitInterfaceImplementationSymbols, withImplicitSymbolFilter: false);
+        }
+
+        private static ISymbolFilter GetCompositeSymbolFilter(DocIdSymbolFilter? customFilter,
+                                                                      bool respectInternals,
+                                                                      bool includeEffectivelyPrivateSymbols,
+                                                                      bool includeExplicitInterfaceImplementationSymbols,
+                                                                      bool withImplicitSymbolFilter)
+        {
+            AccessibilitySymbolFilter accessibilitySymbolFilter = new(
+                    respectInternals,
+                    includeEffectivelyPrivateSymbols,
+                    includeExplicitInterfaceImplementationSymbols);
+
+            CompositeSymbolFilter filter = new();
+
+            if (customFilter != null)
+            {
+                filter.Add(customFilter);
+            }
+            if (withImplicitSymbolFilter)
+            {
+                filter.Add(new ImplicitSymbolFilter());
+            }
+
+            filter.Add(accessibilitySymbolFilter);
+
+            return filter;
+        }
 
         /// <summary>
         /// Determines whether the <see cref="ISymbol"/> should be included.