Refactor: Enhance InterfaceBuilder to utilize Lines, streamline nullable handling, and integrate FileHeader for improved interface generation

NikolayPianikov · NikolayPianikov · commit 3ecff3df73ef · 2026-04-24T18:21:02.000+03:00
diff --git a/src/Pure.DI.Core/Core/Code/Parts/FileHeader.cs b/src/Pure.DI.Core/Core/Code/Parts/FileHeader.cs
@@ -0,0 +1,13 @@
+﻿namespace Pure.DI.Core.Code.Parts;
+
+class FileHeader(IInformation information) : IFileHeader
+{
+    public void Add(Compilation compilation, Lines code)
+    {
+        code.AppendComments("<auto-generated/>", $"by {information.Description}");
+        if (compilation.Options.NullableContextOptions != NullableContextOptions.Disable)
+        {
+            code.AppendLine("#nullable enable annotations");
+        }
+    }
+}
diff --git a/src/Pure.DI.Core/Core/Code/Parts/IFileHeader.cs b/src/Pure.DI.Core/Core/Code/Parts/IFileHeader.cs
@@ -0,0 +1,6 @@
+﻿namespace Pure.DI.Core.Code.Parts;
+
+interface IFileHeader
+{
+    void Add(Compilation compilation, Lines code);
+}
diff --git a/src/Pure.DI.Core/Generator.cs b/src/Pure.DI.Core/Generator.cs
@@ -16,6 +16,7 @@ namespace Pure.DI;
 using static Tag;
 using static Unit;
 using Metadata = Core.Metadata;
+using Interfaces = InterfaceGeneration;
 
 // @formatter:off
 public sealed partial class Generator
@@ -51,9 +52,11 @@ private void Setup() => DI.Setup()
 
         // Interface generator
         .PerBlock<
-            InterfaceGeneration.InterfaceGenerator,
-            InterfaceGeneration.RoslynSymbols,
-            InterfaceGeneration.InterfaceBuilder>()
+            Interfaces.InterfaceGenerator,
+            Interfaces.RoslynSymbols,
+            Interfaces.InterfaceBuilder>()
+
+        .Transient<Interfaces.InterfaceCodeBuilder>()
 
         // Transient
             .Transient(_ => GetType().Assembly)
@@ -82,7 +85,7 @@ private void Setup() => DI.Setup()
                 NodeTools, LocalFunctions, ExceptionHandler, WildcardMatcher, InjectionSiteFactory, Semantic, Attributes, Compilations, GraphWalker<TT, TT1>,
                 LifetimeAnalyzer, InstanceDpProvider, Injections, NameFormatter, BindingsFactory, NodesFactory, LocationProvider,
                 CycleTools, LifetimeProvider, VarDeclarationTools, ContractTagComparer,
-                CodeNameProvider, DependencyNodePrioritizer>()
+                CodeNameProvider, DependencyNodePrioritizer, FileHeader>()
             .PerBlock<LifetimesValidatorVisitor, CyclicDependencyValidatorVisitor, RootArgsVisitor, RootStatisticsVisitor>()
             .PerBlock<GraphOverrider>(Overrider)
             .PerBlock<GraphCleaner>(Cleaner)
diff --git a/src/Pure.DI.Core/InterfaceGeneration/GeneratedInterfaceDetails.cs b/src/Pure.DI.Core/InterfaceGeneration/GeneratedInterfaceDetails.cs
@@ -1,14 +1,18 @@
 namespace Pure.DI.InterfaceGeneration;
 
+using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 sealed class GeneratedInterfaceDetails(
+    SemanticModel semanticModel,
     AttributeData? generationAttribute,
     ITypeSymbol typeSymbol,
     ClassDeclarationSyntax classSyntax)
 {
+    public SemanticModel SemanticModel { get; } = semanticModel;
+
     public string NamespaceName { get; } = PrepareNamespaceValue(generationAttribute, typeSymbol.ContainingNamespace.ToDisplayString());
 
     public string InterfaceName { get; } = PrepareValue(
@@ -23,6 +27,16 @@ sealed class GeneratedInterfaceDetails(
         ? "internal"
         : "public";
 
+    public string ClassDocumentation { get; set; } = string.Empty;
+
+    public string GenericType { get; set; } = string.Empty;
+
+    public ImmutableArray<PropertyInfo> PropertyInfos { get; set; } = ImmutableArray<PropertyInfo>.Empty;
+
+    public ImmutableArray<MethodInfo> MethodInfos { get; set; } = ImmutableArray<MethodInfo>.Empty;
+
+    public ImmutableArray<EventInfo> Events { get; set; } = ImmutableArray<EventInfo>.Empty;
+
     private static string PrepareNamespaceValue(AttributeData? generationAttribute, string defaultValue) =>
         PrepareValue(generationAttribute, Names.NamespaceParameterName, defaultValue);
 
diff --git a/src/Pure.DI.Core/InterfaceGeneration/IInterfaceBuilder.cs b/src/Pure.DI.Core/InterfaceGeneration/IInterfaceBuilder.cs
@@ -2,7 +2,7 @@
 
 interface IInterfaceBuilder
 {
-    string BuildInterfaceFor(
+    Lines BuildInterfaceFor(
         SemanticModel semanticModel,
         ITypeSymbol typeSymbol,
         ClassDeclarationSyntax classSyntax);
diff --git a/src/Pure.DI.Core/InterfaceGeneration/InterfaceBuilder.cs b/src/Pure.DI.Core/InterfaceGeneration/InterfaceBuilder.cs
@@ -1,7 +1,9 @@
+// ReSharper disable LoopCanBeConvertedToQuery
 namespace Pure.DI.InterfaceGeneration;
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Text;
 using Microsoft.CodeAnalysis;
@@ -10,7 +12,9 @@ namespace Pure.DI.InterfaceGeneration;
 
 sealed class InterfaceBuilder(
     IRoslynSymbols roslynSymbols,
-    ITypes types): IInterfaceBuilder
+    ITypes types,
+    Func<IBuilder<GeneratedInterfaceDetails, Lines>> interfaceCodeBuilderFactory)
+    : IInterfaceBuilder
 {
     private static readonly SymbolDisplayFormat FullyQualifiedDisplayFormat = new(
         genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
@@ -28,68 +32,74 @@ sealed class InterfaceBuilder(
         globalNamespaceStyle: FullyQualifiedDisplayFormat.GlobalNamespaceStyle,
         miscellaneousOptions: FullyQualifiedDisplayFormat.MiscellaneousOptions);
 
-    public string BuildInterfaceFor(SemanticModel semanticModel, ITypeSymbol typeSymbol, ClassDeclarationSyntax classSyntax)
+    public Lines BuildInterfaceFor(SemanticModel semanticModel, ITypeSymbol typeSymbol, ClassDeclarationSyntax classSyntax)
     {
         if (typeSymbol is not INamedTypeSymbol namedTypeSymbol)
         {
-            return string.Empty;
+            return new Lines();
         }
 
         var generationAttribute = typeSymbol.GetAttributes().FirstOrDefault(x =>
             x.AttributeClass != null && x.AttributeClass.Name.Contains(Names.GenerateInterfaceAttributeName, StringComparison.Ordinal));
 
-        var symbolDetails = new GeneratedInterfaceDetails(generationAttribute, typeSymbol, classSyntax);
-        var interfaceGenerator = new InterfaceCodeBuilder(symbolDetails.NamespaceName, symbolDetails.InterfaceName, symbolDetails.AccessLevel);
-
-        interfaceGenerator.AddClassDocumentation(GetDocumentationForClass(classSyntax));
-        interfaceGenerator.AddGeneric(GetGeneric(classSyntax, namedTypeSymbol));
+        var symbolDetails = new GeneratedInterfaceDetails(semanticModel, generationAttribute, typeSymbol, classSyntax)
+        {
+            ClassDocumentation = GetDocumentationForClass(classSyntax),
+            GenericType = GetGeneric(classSyntax, namedTypeSymbol)
+        };
 
         var members = roslynSymbols.GetAllMembers(typeSymbol)
             .Where(x => x.DeclaredAccessibility == Accessibility.Public)
             .Where(x => !x.IsStatic)
             .Where(x => !HasIgnoreAttribute(x))
             .ToList();
 
-        AddPropertiesToInterface(members, interfaceGenerator);
-        AddMethodsToInterface(semanticModel, members, interfaceGenerator);
-        AddEventsToInterface(members, interfaceGenerator);
+        var hasNullable = false;
+        symbolDetails.PropertyInfos = GetProperties(members, ref hasNullable);
+        symbolDetails.MethodInfos = GetMethods(semanticModel, members, ref hasNullable);
+        symbolDetails.Events = GetEvents(members, ref hasNullable);
 
-        return interfaceGenerator.Build();
+        return interfaceCodeBuilderFactory().Build(symbolDetails);
     }
 
-    private void AddMethodsToInterface(SemanticModel semanticModel, List<ISymbol> members, InterfaceCodeBuilder codeGenerator)
+    private ImmutableArray<MethodInfo> GetMethods(SemanticModel semanticModel, List<ISymbol> members, ref bool hasNullable)
     {
-        members.Where(x => x.Kind == SymbolKind.Method)
-            .OfType<IMethodSymbol>()
-            .Where(x => x.MethodKind is MethodKind.Ordinary)
-            .Where(x => !types.TypeEquals(x.ContainingType, semanticModel.Compilation.GetSpecialType(SpecialType.System_Object)))
-            .Where(x => !HasIgnoreAttribute(x))
-            .GroupBy(x => x.ToDisplayString(FullyQualifiedDisplayFormatForGrouping))
-            .Select(g => g.First())
-            .ToList()
-            .ForEach(method => AddMethod(codeGenerator, method));
+        var methods = new List<MethodInfo>();
+        foreach (var method in members.Where(x => x.Kind == SymbolKind.Method)
+                     .OfType<IMethodSymbol>()
+                     .Where(x => x.MethodKind is MethodKind.Ordinary)
+                     .Where(x => !types.TypeEquals(x.ContainingType, semanticModel.Compilation.GetSpecialType(SpecialType.System_Object)))
+                     .Where(x => !HasIgnoreAttribute(x))
+                     .GroupBy(x => x.ToDisplayString(FullyQualifiedDisplayFormatForGrouping))
+                     .Select(g => g.First()))
+        {
+            methods.Add(GetMethodInfo(method, ref hasNullable));
+        }
+
+        return methods.ToImmutableArray();
     }
 
-    private void AddMethod(InterfaceCodeBuilder codeGenerator, IMethodSymbol method)
+    private MethodInfo GetMethodInfo(IMethodSymbol method, ref bool hasNullable)
     {
-        ActivateNullableIfNeeded(codeGenerator, method);
+        ActivateNullableIfNeeded(ref hasNullable, method);
 
         var paramResult = new HashSet<string>();
-        foreach (var parameter in method.Parameters.Select(p => GetParameterDisplayString(p, codeGenerator.HasNullable)))
+        foreach (var methodParameter in method.Parameters)
         {
+            var parameter = GetParameterDisplayString(methodParameter, hasNullable);
             paramResult.Add(parameter);
         }
 
         var typedArgs = method.TypeParameters
             .Select(arg => (arg.ToDisplayString(FullyQualifiedDisplayFormat), roslynSymbols.GetWhereStatement(arg, FullyQualifiedDisplayFormat)))
             .ToList();
 
-        codeGenerator.AddMethodToInterface(
+        return new MethodInfo(
             method.Name,
             GetMethodReturnType(method),
             InheritDoc(method),
-            paramResult,
-            typedArgs);
+            paramResult.ToImmutableArray(),
+            typedArgs.ToImmutableArray());
     }
 
     private static string GetMethodReturnType(IMethodSymbol method)
@@ -98,19 +108,19 @@ private static string GetMethodReturnType(IMethodSymbol method)
         return prefix + method.ReturnType.ToDisplayString(FullyQualifiedDisplayFormat);
     }
 
-    private static void ActivateNullableIfNeeded(InterfaceCodeBuilder codeGenerator, ITypeSymbol typeSymbol)
+    private static void ActivateNullableIfNeeded(ref bool hasNullable, ITypeSymbol typeSymbol)
     {
         if (IsNullable(typeSymbol))
         {
-            codeGenerator.HasNullable = true;
+            hasNullable = true;
         }
     }
 
-    private static void ActivateNullableIfNeeded(InterfaceCodeBuilder codeGenerator, IMethodSymbol method)
+    private static void ActivateNullableIfNeeded(ref bool hasNullable, IMethodSymbol method)
     {
         if (method.Parameters.Any(x => IsNullable(x.Type)) || IsNullable(method.ReturnType))
         {
-            codeGenerator.HasNullable = true;
+            hasNullable = true;
         }
     }
 
@@ -172,40 +182,42 @@ private static string GetParameterDisplayString(IParameterSymbol param, bool nul
         return typeSb.Append(restSb).ToString();
     }
 
-    private static void AddEventsToInterface(List<ISymbol> members, InterfaceCodeBuilder codeGenerator)
+    private static ImmutableArray<EventInfo> GetEvents(List<ISymbol> members, ref bool hasNullable)
     {
-        members.Where(x => x.Kind == SymbolKind.Event)
-            .OfType<IEventSymbol>()
-            .GroupBy(x => x.ToDisplayString(FullyQualifiedDisplayFormatForGrouping))
-            .Select(g => g.First())
-            .ToList()
-            .ForEach(evt =>
-            {
-                ActivateNullableIfNeeded(codeGenerator, evt.Type);
-                codeGenerator.AddEventToInterface(evt.Name, evt.Type.ToDisplayString(FullyQualifiedDisplayFormat), InheritDoc(evt));
-            });
+        var events = new List<EventInfo>();
+        foreach (var evt in members.Where(x => x.Kind == SymbolKind.Event)
+                     .OfType<IEventSymbol>()
+                     .GroupBy(x => x.ToDisplayString(FullyQualifiedDisplayFormatForGrouping))
+                     .Select(g => g.First()))
+        {
+            ActivateNullableIfNeeded(ref hasNullable, evt.Type);
+            events.Add(new EventInfo(evt.Name, evt.Type.ToDisplayString(FullyQualifiedDisplayFormat), InheritDoc(evt)));
+        }
+
+        return events.ToImmutableArray();
     }
 
-    private static void AddPropertiesToInterface(List<ISymbol> members, InterfaceCodeBuilder interfaceGenerator)
+    private static ImmutableArray<PropertyInfo> GetProperties(List<ISymbol> members, ref bool hasNullable)
     {
-        members.Where(x => x.Kind == SymbolKind.Property)
-            .OfType<IPropertySymbol>()
-            .Where(x => !x.IsIndexer)
-            .GroupBy(x => x.Name)
-            .Select(g => g.First())
-            .ToList()
-            .ForEach(prop =>
-            {
-                ActivateNullableIfNeeded(interfaceGenerator, prop.Type);
-
-                interfaceGenerator.AddPropertyToInterface(
-                    prop.Name,
-                    prop.Type.ToDisplayString(FullyQualifiedDisplayFormat),
-                    prop.GetMethod?.DeclaredAccessibility == Accessibility.Public,
-                    GetSetKind(prop.SetMethod),
-                    prop.ReturnsByRef,
-                    InheritDoc(prop));
-            });
+        var properties = new List<PropertyInfo>();
+        foreach (var prop in members.Where(x => x.Kind == SymbolKind.Property)
+                     .OfType<IPropertySymbol>()
+                     .Where(x => !x.IsIndexer)
+                     .GroupBy(x => x.Name)
+                     .Select(g => g.First()))
+        {
+            ActivateNullableIfNeeded(ref hasNullable, prop.Type);
+
+            properties.Add(new PropertyInfo(
+                prop.Name,
+                prop.Type.ToDisplayString(FullyQualifiedDisplayFormat),
+                prop.GetMethod?.DeclaredAccessibility == Accessibility.Public,
+                GetSetKind(prop.SetMethod),
+                prop.ReturnsByRef,
+                InheritDoc(prop)));
+        }
+
+        return properties.ToImmutableArray();
     }
 
     private static PropertySetKind GetSetKind(IMethodSymbol? setMethodSymbol) =>
@@ -251,4 +263,4 @@ private string GetGeneric(TypeDeclarationSyntax classSyntax, INamedTypeSymbol ty
 
     private static string InheritDoc(ISymbol source) =>
         $"/// <inheritdoc cref=\"{source.ToDisplayString().Replace("<", "{").Replace(">", "}").Replace("params ", string.Empty)}\" />";
-}
+}
diff --git a/src/Pure.DI.Core/InterfaceGeneration/InterfaceCodeBuilder.cs b/src/Pure.DI.Core/InterfaceGeneration/InterfaceCodeBuilder.cs
diff --git a/src/Pure.DI.Core/InterfaceGeneration/InterfaceGenerator.cs b/src/Pure.DI.Core/InterfaceGeneration/InterfaceGenerator.cs

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`interface IInterfaceBuilder`
`4`	`4`	`{`
`5`		`- string BuildInterfaceFor(`
	`5`	`+ Lines BuildInterfaceFor(`
`6`	`6`	`SemanticModel semanticModel,`
`7`	`7`	`ITypeSymbol typeSymbol,`
`8`	`8`	`ClassDeclarationSyntax classSyntax);`