Refactor FilterGenerator to use IIncrementalGenerator instead of deprecated ISourceGenerator

This also gets rid of unused  code

Author: curtisy1

src/AutoFilterer.Generators/AttributeSyntaxReceiver.cs

@@ -2,74 +2,85 @@
 using Microsoft.CodeAnalysis.Text;
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using DotNurse.CodeAnalysis;
-using AutoFilterer.Generators.Extensions;
 using Microsoft.CodeAnalysis.CSharp;
-using System.Diagnostics;
 
 namespace AutoFilterer.Generators;
 
+using Extensions;
+
 [Generator]
-public class FilterGenerator : ISourceGenerator
+public class FilterGenerator : IIncrementalGenerator
 {
-    public void Initialize(GeneratorInitializationContext context)
+    public void Initialize(IncrementalGeneratorInitializationContext context)
     {
-        context.RegisterForSyntaxNotifications(() => new AttributeSyntaxReceiver<GenerateAutoFilterAttribute>());
+        var classDeclarations = context.SyntaxProvider
+            .CreateSyntaxProvider(
+                predicate: static (s, _) => s is ClassDeclarationSyntax { AttributeLists.Count: > 0 },
+                transform: static (ctx, _) => GetSemanticTargetForGeneration(ctx))
+            .Where(static m => m is not null);
+
+        var compilationAndClasses = context.CompilationProvider.Combine(classDeclarations.Collect());
+
+        context.RegisterSourceOutput(compilationAndClasses, (spc, source) => Execute(source.Left, source.Right, spc));
     }
 
-    public void Execute(GeneratorExecutionContext context)
+    private static ClassDeclarationSyntax GetSemanticTargetForGeneration(GeneratorSyntaxContext context)
     {
-        if (!(context.SyntaxReceiver is AttributeSyntaxReceiver<GenerateAutoFilterAttribute> receiver))
-            return;
+        var classDeclaration = (ClassDeclarationSyntax)context.Node;
 
-        //if (!Debugger.IsAttached)
-        //{
-        //    Debugger.Launch();
-        //}
-
-        foreach (var classSyntax in receiver.Classes)
+        foreach (var attributeList in classDeclaration.AttributeLists)
         {
-            var attribute = classSyntax.AttributeLists.SelectMany(sm => sm.Attributes).FirstOrDefault(x => x.Name.ToString().EnsureEndsWith("Attribute").Equals(typeof(GenerateAutoFilterAttribute).Name));
-            var namespaceParam = attribute.ArgumentList?.Arguments.FirstOrDefault(); // Temprorary... Attribute has only one argument for now.
-
-            var model = context.Compilation.GetSemanticModel(classSyntax.SyntaxTree);
-            var symbol = model.GetDeclaredSymbol(classSyntax);
-            var attrs = symbol.GetAttributes();
-
-            var realNamespace = GetNamespaceRecursively(symbol.ContainingNamespace);
+            foreach (var attribute in attributeList.Attributes)
+            {
+                var symbolInfo = context.SemanticModel.GetSymbolInfo(attribute);
+                var attributeSymbol = symbolInfo.Symbol as IMethodSymbol;
 
-            var properties = symbol.GetMembers().OfType<IPropertySymbol>()
-            .Where(x => !x.IsStatic && !x.ContainingType.IsGenericType && x.Kind == SymbolKind.Property);
+                var fullName = attributeSymbol?.ContainingType.ToDisplayString()
+                                  ?? attribute.Name.ToString();
 
-            context.AddSource($"{symbol.Name}FilterDto.g.cs",
-                   SourceText.From(GetFilterDtoCode(symbol.Name, properties, namespaceParam?.ToString().Trim('\"') ?? realNamespace), Encoding.UTF8));
+                if (fullName.EnsureEndsWith("Attribute").EndsWith(nameof(GenerateAutoFilterAttribute)))
+                {
+                    return classDeclaration;
+                }
+            }
         }
+
+        return null;
     }
 
-    private static Dictionary<INamedTypeSymbol, IList<AttributeData>> GetClassAttributePairs(GeneratorExecutionContext context,
-        SyntaxReceiver receiver)
+    private static void Execute(Compilation compilation, ImmutableArray<ClassDeclarationSyntax> classes, SourceProductionContext context)
     {
-        var compilation = context.Compilation;
-        var classSymbols = new Dictionary<INamedTypeSymbol, IList<AttributeData>>();
-        foreach (var clazz in receiver.CandidateClasses)
+        if (classes.IsDefaultOrEmpty) {
+            return;
+        }
+
+        foreach (var classSyntax in classes)
         {
-            var model = compilation.GetSemanticModel(clazz.SyntaxTree);
-            var classSymbol = model.GetDeclaredSymbol(clazz);
-            var attributes = classSymbol.GetAttributes();
-            if (attributes.Any(ad => ad.AttributeClass.Name == nameof(GenerateAutoFilterAttribute)))
+            var model = compilation.GetSemanticModel(classSyntax.SyntaxTree);
+            if (model.GetDeclaredSymbol(classSyntax) is not { } symbol)
             {
-                classSymbols.Add((INamedTypeSymbol)classSymbol, attributes.ToList());
+                continue;
             }
-        }
 
-        return classSymbols;
+            var attribute = symbol.GetAttributes()
+                .FirstOrDefault(a => a.AttributeClass?.Name == nameof(GenerateAutoFilterAttribute));
+            var namespaceParam = attribute?.ConstructorArguments.FirstOrDefault().Value?.ToString().Trim('\"'); // Temprorary... Attribute has only one argument for now.
+            var realNamespace = GetNamespaceRecursively(symbol.ContainingNamespace);
+
+            var properties = symbol.GetMembers().OfType<IPropertySymbol>()
+                .Where(x => !x.IsStatic && !x.ContainingType.IsGenericType && x.Kind == SymbolKind.Property);
+
+            var sourceCode = GetFilterDtoCode(symbol.Name, properties, namespaceParam ?? realNamespace);
+
+            context.AddSource($"{symbol.Name}FilterDto.g.cs", SourceText.From(sourceCode, Encoding.UTF8));
+        }
     }
 
-    internal string GetFilterDtoCode(string className, IEnumerable<IPropertySymbol> properties,
+    private static string GetFilterDtoCode(string className, IEnumerable<IPropertySymbol> properties,
         string @namespace = null)
     {
         var start = $@"
@@ -88,10 +99,11 @@ public partial class {className}Filter : PaginationFilterBase
 
         foreach (var property in properties)
         {
-            string propertyType = property.Type.ToDisplayString(NullableFlowState.None);
+            var propertyType = property.Type.ToDisplayString(NullableFlowState.None);
 
-            if (TypeMapping.Mappings.TryGetValue(propertyType, out var mapped))
+            if (TypeMapping.Mappings.TryGetValue(propertyType, out var mapped)) {
                 propertyType = mapped;
+            }
 
             if (propertyType.Equals(nameof(String), StringComparison.InvariantCultureIgnoreCase))
             {
@@ -100,13 +112,10 @@ public partial class {className}Filter : PaginationFilterBase
             body.AppendLine($"\t\tpublic virtual {propertyType} {property.Name} {{ get; set; }}");
         }
 
-        var end = "\t}\n}";
-
-
-        return start + body.ToString() + end;
+        return start + body + "\t}\n}";
     }
 
-    private string GetNamespaceRecursively(INamespaceSymbol symbol)
+    private static string GetNamespaceRecursively(INamespaceSymbol symbol)
     {
         if (symbol.ContainingNamespace == null)
         {
@@ -115,4 +124,4 @@ private string GetNamespaceRecursively(INamespaceSymbol symbol)
 
         return (GetNamespaceRecursively(symbol.ContainingNamespace) + "." + symbol.Name).Trim('.');
     }
-}
+}

src/AutoFilterer.Generators/FilterGenerator.cs

@@ -9,8 +9,8 @@ public GenerateAutoFilterAttribute()
 
     public GenerateAutoFilterAttribute(string @namespace)
     {
-        Namespace = @Namespace;
+        Namespace = @namespace;
     }
 
     public string Namespace { get; }
-}
+}