refactor(generator): remove collection of required usings & move redundant code to utils

Author: DerStimmler

CSharpFunctionalExtensions.HttpResults.Generators/Builders/ClassBuilder.cs

@@ -1,42 +1,31 @@
 using System.Text;
+using CSharpFunctionalExtensions.HttpResults.Generators.Utils;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace CSharpFunctionalExtensions.HttpResults.Generators.Builders;
 
 public abstract class ClassBuilder
 {
-  private static readonly SymbolDisplayFormat FullyQualifiedWithNullables =
-    SymbolDisplayFormat.FullyQualifiedFormat.WithMiscellaneousOptions(
-      SymbolDisplayFormat.FullyQualifiedFormat.MiscellaneousOptions
-        | SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier
-    );
-
   private const string MapMethodName = "Map";
-  private readonly List<ClassDeclarationSyntax> _mapperClasses;
-  private readonly HashSet<string> _requiredNamespaces;
   private readonly Compilation? _compilation;
+  private readonly List<ClassDeclarationSyntax> _mapperClasses;
 
-  protected ClassBuilder(
-    HashSet<string> requiredNamespaces,
-    List<ClassDeclarationSyntax> mapperClasses,
-    Compilation? compilation = null
-  )
+  protected ClassBuilder(List<ClassDeclarationSyntax> mapperClasses, Compilation? compilation = null)
   {
-    _requiredNamespaces = requiredNamespaces;
     _mapperClasses = mapperClasses;
     _compilation = compilation;
   }
 
   private static string DefaultUsings =>
     """
       using CSharpFunctionalExtensions;
-      using IResult = Microsoft.AspNetCore.Http.IResult;
       using Microsoft.AspNetCore.Http.HttpResults;
       using Microsoft.AspNetCore.Http;
       using Microsoft.AspNetCore.Mvc;
       using Microsoft.Net.Http.Headers;
       using System.Text;
+      using IResult = Microsoft.AspNetCore.Http.IResult;
       """;
 
   public string SourceFileName => $"{ClassName}.g.cs";
@@ -55,13 +44,6 @@ public string Build()
     sourceBuilder.AppendLine();
     sourceBuilder.AppendLine(DefaultUsings);
 
-    _requiredNamespaces
-      .Where(@namespace => !@namespace.StartsWith("global"))
-      .Distinct()
-      .Select(@namespace => $"using {@namespace};")
-      .ToList()
-      .ForEach(@using => sourceBuilder.AppendLine(@using));
-
     sourceBuilder.AppendLine();
     sourceBuilder.AppendLine(ClassSummary);
 
@@ -82,7 +64,7 @@ public string Build()
         throw new ArgumentException($"Mapping method in class {mapperClassName} must have exactly one parameter.");
 
       var resultErrorType = GetFullyQualifiedTypeName(mapperClass, mappingMethod.ParameterList.Parameters[0].Type!);
-      var httpResultType = GetFullyQualifiedTypeName(mapperClass, mappingMethod.ReturnType!);
+      var httpResultType = mappingMethod.ReturnType!.ToString();
 
       foreach (var methodGenerator in MethodGenerators)
       {
@@ -108,6 +90,6 @@ private string GetFullyQualifiedTypeName(ClassDeclarationSyntax mapperClass, Typ
     if (typeInfo.Type == null)
       return typeSyntax.ToString();
 
-    return typeInfo.Type.ToDisplayString(FullyQualifiedWithNullables);
+    return TypeNameResolver.GetFullyQualifiedTypeName(typeInfo.Type);
   }
 }

CSharpFunctionalExtensions.HttpResults.Generators/Builders/ResultExtensionsClassBuilder.cs

@@ -5,10 +5,9 @@
 namespace CSharpFunctionalExtensions.HttpResults.Generators.Builders;
 
 public class ResultExtensionsClassBuilder(
-  HashSet<string> requiredNamespaces,
   List<ClassDeclarationSyntax> mapperClasses,
   Compilation? compilation = null
-) : ClassBuilder(requiredNamespaces, mapperClasses, compilation)
+) : ClassBuilder(mapperClasses, compilation)
 {
   protected override string ClassName => "ResultExtensions";
 

CSharpFunctionalExtensions.HttpResults.Generators/Builders/UnitResultExtensionsClassBuilder.cs

@@ -5,10 +5,9 @@
 namespace CSharpFunctionalExtensions.HttpResults.Generators.Builders;
 
 public class UnitResultExtensionsClassBuilder(
-  HashSet<string> requiredNamespaces,
   List<ClassDeclarationSyntax> mapperClasses,
   Compilation? compilation = null
-) : ClassBuilder(requiredNamespaces, mapperClasses, compilation)
+) : ClassBuilder(mapperClasses, compilation)
 {
   protected override string ClassName => "UnitResultExtensions";
 

CSharpFunctionalExtensions.HttpResults.Generators/ResultExtensionsGenerator.cs

@@ -1,5 +1,6 @@
 using System.Text;
 using CSharpFunctionalExtensions.HttpResults.Generators.Builders;
+using CSharpFunctionalExtensions.HttpResults.Generators.Utils;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
@@ -43,33 +44,28 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         var (compilation, classDeclarations) = source;
 
         var mapperClasses = new List<ClassDeclarationSyntax>();
-        var requiredNamespaces = new HashSet<string>();
 
         Parallel.ForEach(
           classDeclarations,
           classDeclaration =>
           {
-            var semanticModel = compilation.GetSemanticModel(classDeclaration.SyntaxTree);
-            var namespaceName = GetNamespace(classDeclaration, semanticModel);
-
             lock (mapperClasses)
             {
               mapperClasses.Add(classDeclaration);
-              requiredNamespaces.Add(namespaceName);
             }
           }
         );
 
         if (!ResultExtensionsGeneratorValidator.CheckRules(mapperClasses, context))
           return;
 
-        var (fileName, sourceText) = CreateErrorMapperInstancesClass(mapperClasses, requiredNamespaces);
+        var (fileName, sourceText) = CreateErrorMapperInstancesClass(mapperClasses, compilation);
         context.AddSource(fileName, SourceText.From(sourceText, Encoding.UTF8));
 
         var classBuilders = new List<ClassBuilder>
         {
-          new ResultExtensionsClassBuilder(requiredNamespaces, mapperClasses, compilation),
-          new UnitResultExtensionsClassBuilder(requiredNamespaces, mapperClasses, compilation),
+          new ResultExtensionsClassBuilder(mapperClasses, compilation),
+          new UnitResultExtensionsClassBuilder(mapperClasses, compilation),
         };
 
         foreach (var classBuilder in classBuilders)
@@ -83,7 +79,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
   /// </summary>
   private static (string FileName, string SourceText) CreateErrorMapperInstancesClass(
     List<ClassDeclarationSyntax> mapperClasses,
-    HashSet<string> requiredNamespaces
+    Compilation compilation
   )
   {
     var sourceBuilder = new StringBuilder();
@@ -92,20 +88,20 @@ HashSet<string> requiredNamespaces
     sourceBuilder.AppendLine();
     sourceBuilder.AppendLine("#nullable enable");
     sourceBuilder.AppendLine();
-    requiredNamespaces
-      .Where(@namespace => !@namespace.StartsWith("global"))
-      .Distinct()
-      .Select(@namespace => $"using {@namespace};")
-      .ToList()
-      .ForEach(@using => sourceBuilder.AppendLine(@using));
     sourceBuilder.AppendLine();
 
     sourceBuilder.AppendLine("public static class ErrorMapperInstances {");
 
-    foreach (var mapperName in mapperClasses)
-      sourceBuilder.AppendLine(
-        $"    public static {mapperName.Identifier.Text} {mapperName.Identifier.Text} {{ get; }} = new();"
-      );
+    foreach (var mapper in mapperClasses)
+    {
+      var semanticModel = compilation.GetSemanticModel(mapper.SyntaxTree);
+
+      if (semanticModel.GetDeclaredSymbol(mapper) is not ITypeSymbol mapperSymbol)
+        continue;
+
+      var mapperType = TypeNameResolver.GetFullyQualifiedTypeName(mapperSymbol);
+      sourceBuilder.AppendLine($"    public static {mapperType} {mapper.Identifier.Text} {{ get; }} = new();");
+    }
 
     sourceBuilder.AppendLine("}");
 
@@ -127,16 +123,4 @@ private static bool ImplementsResultErrorMapper(ITypeSymbol? classSymbol)
       interfaceSymbol.Name.StartsWith(ResultErrorMapperInterface)
     );
   }
-
-  /// <summary>
-  ///   Retrieves the namespace of a class declaration.
-  /// </summary>
-  /// <param name="classDeclaration">The class declaration syntax node.</param>
-  /// <param name="semanticModel">The semantic model for the syntax tree.</param>
-  /// <returns>The namespace of the class, or an empty string if the namespace cannot be determined.</returns>
-  private static string GetNamespace(ClassDeclarationSyntax classDeclaration, SemanticModel semanticModel)
-  {
-    var symbol = semanticModel.GetDeclaredSymbol(classDeclaration);
-    return symbol?.ContainingNamespace?.ToString() ?? string.Empty;
-  }
 }

CSharpFunctionalExtensions.HttpResults.Generators/Utils/TypeNameResolver.cs

@@ -0,0 +1,17 @@
+using Microsoft.CodeAnalysis;
+
+namespace CSharpFunctionalExtensions.HttpResults.Generators.Utils;
+
+internal static class TypeNameResolver
+{
+  private static readonly SymbolDisplayFormat FullyQualifiedWithNullables =
+    SymbolDisplayFormat.FullyQualifiedFormat.WithMiscellaneousOptions(
+      SymbolDisplayFormat.FullyQualifiedFormat.MiscellaneousOptions
+        | SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier
+    );
+
+  public static string GetFullyQualifiedTypeName(ITypeSymbol typeSymbol)
+  {
+    return typeSymbol.ToDisplayString(FullyQualifiedWithNullables);
+  }
+}