Use factory methods instead of fluent. Get rid of GenAPIConfiguration, split it into two separate classes.

Author: carlossanlop

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

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Build.Framework;
+using Microsoft.CodeAnalysis;
+using Microsoft.DotNet.ApiSymbolExtensions;
 using Microsoft.DotNet.ApiSymbolExtensions.Logging;
 using Microsoft.NET.Build.Tasks;
 
@@ -62,20 +64,20 @@ public class GenAPITask : TaskBase
         /// <inheritdoc />
         protected override void ExecuteCore()
         {
-            GenAPIConfiguration config = GenAPIConfiguration.GetBuilder()
-                .WithAssembliesPaths(Assemblies)
-                .WithAssemblyReferencesPaths(AssemblyReferences)
-                .WithRespectInternals(RespectInternals)
-                .Build();
+            (IAssemblySymbolLoader loader, Dictionary<string, IAssemblySymbol> assemblySymbols) = AssemblyLoaderFactory.CreateFromFiles(
+                assembliesPaths: Assemblies ?? throw new NullReferenceException("Assemblies cannot be null."),
+                assemblyReferencesPaths: AssemblyReferences,
+                RespectInternals);
 
             GenAPIApp.Run(new MSBuildLog(Log),
-                          config.AssemblySymbols,
+                          loader,
+                          assemblySymbols,
                           OutputPath,
-                          config.Loader,
-                          GenAPIConfiguration.GetSymbolFilterFromFiles(ExcludeApiFiles, respectInternals: RespectInternals),
-                          GenAPIConfiguration.GetAttributeFilterFromPaths(ExcludeAttributesFiles, respectInternals: RespectInternals),
-                          GenAPIConfiguration.GetFormattedHeader(HeaderFile),
+                          HeaderFile,
                           ExceptionMessage,
+                          ExcludeApiFiles,
+                          ExcludeAttributesFiles,
+                          RespectInternals,
                           IncludeAssemblyAttributes);
         }
     }

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

@@ -5,6 +5,8 @@
 using System.CommandLine.Parsing;
 using System.Diagnostics;
 using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Microsoft.DotNet.ApiSymbolExtensions;
 using Microsoft.DotNet.ApiSymbolExtensions.Logging;
 
 namespace Microsoft.DotNet.GenAPI.Tool
@@ -97,23 +99,24 @@ static int Main(string[] args)
 
             rootCommand.SetAction((ParseResult parseResult) =>
             {
-                GenAPIConfiguration config = GenAPIConfiguration.GetBuilder()
-                    .WithAssembliesPaths(parseResult.GetValue(assembliesOption)!)
-                    .WithAssemblyReferencesPaths(parseResult.GetValue(assemblyReferencesOption))
-                    .WithRespectInternals(parseResult.GetValue(respectInternalsOption))
-                    .Build();
-
                 bool respectInternals = parseResult.GetValue(respectInternalsOption);
 
+                (IAssemblySymbolLoader loader, Dictionary<string, IAssemblySymbol> assemblySymbols) = AssemblyLoaderFactory.CreateFromFiles(
+                    assembliesPaths: parseResult.GetValue(assembliesOption) ?? throw new NullReferenceException("No assemblies provided."),
+                    assemblyReferencesPaths: parseResult.GetValue(assemblyReferencesOption),
+                    respectInternals);
+
                 GenAPIApp.Run(new ConsoleLog(MessageImportance.Normal),
-                              config.AssemblySymbols,
-                              parseResult.GetValue(outputPathOption),
-                              config.Loader,
-                              GenAPIConfiguration.GetSymbolFilterFromFiles(parseResult.GetValue(excludeApiFilesOption), respectInternals),
-                              GenAPIConfiguration.GetAttributeFilterFromPaths(parseResult.GetValue(excludeAttributesFilesOption), respectInternals),
-                              GenAPIConfiguration.GetFormattedHeader(parseResult.GetValue(headerFileOption)),
-                              parseResult.GetValue(exceptionMessageOption),
-                              parseResult.GetValue(includeAssemblyAttributesOption));
+                    loader,
+                    assemblySymbols,
+                    parseResult.GetValue(outputPathOption),
+                    parseResult.GetValue(headerFileOption),
+                    parseResult.GetValue(exceptionMessageOption),
+                    parseResult.GetValue(excludeApiFilesOption),
+                    parseResult.GetValue(excludeAttributesFilesOption),
+                    respectInternals,
+                    parseResult.GetValue(includeAssemblyAttributesOption)
+                );
             });
 
             return rootCommand.Parse(args).Invoke();

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

@@ -0,0 +1,36 @@
+// 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;
+using Microsoft.DotNet.ApiSymbolExtensions.Filtering;
+using Microsoft.DotNet.GenAPI.Filtering;
+
+namespace Microsoft.DotNet.GenAPI;
+
+public class AssemblyLoaderFactory
+{
+    public static (IAssemblySymbolLoader, Dictionary<string, IAssemblySymbol>) CreateFromFiles(string[] assembliesPaths, string[]? assemblyReferencesPaths, bool respectInternals = false)
+    {
+        AssemblySymbolLoader loader;
+        Dictionary<string, IAssemblySymbol> assemblySymbols;
+
+        if (assembliesPaths.Length == 0)
+        {
+            CreateWithNoAssemblies();
+        }
+
+        bool atLeastOneReferencePath = assemblyReferencesPaths?.Count() > 0;
+        loader = new AssemblySymbolLoader(resolveAssemblyReferences: atLeastOneReferencePath, respectInternals);
+        if (atLeastOneReferencePath)
+        {
+            loader.AddReferenceSearchPaths(assemblyReferencesPaths!);
+        }
+        assemblySymbols = new Dictionary<string, IAssemblySymbol>(loader.LoadAssembliesAsDictionary(assembliesPaths));
+
+        return (loader, assemblySymbols);
+    }
+
+    public static (IAssemblySymbolLoader, Dictionary<string, IAssemblySymbol>) CreateWithNoAssemblies(bool respectInternals = false) =>
+        (new AssemblySymbolLoader(resolveAssemblyReferences: true, includeInternalSymbols: respectInternals), new Dictionary<string, IAssemblySymbol>());
+}