Update Main.cs to use and implement IIncrementalGenerator interface.

Author: CodingFlow

DecoratorGenerator/DecoratorGenerator.csproj

@@ -54,13 +54,13 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4">
+        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-        <PackageReference Include="Microsoft.CodeAnalysis.Common" Version="4.9.2" />
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.9.2" />
-        <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0">
+        <PackageReference Include="Microsoft.CodeAnalysis.Common" Version="5.0.0" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" />
+        <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="10.0.100">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>

DecoratorGenerator/Main.cs

@@ -1,71 +1,41 @@
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
+using System.Threading;
 
 namespace DecoratorGenerator
 {
     [Generator]
-    public class Main : ISourceGenerator
+    public class Main : IIncrementalGenerator
     {
-        public void Initialize(GeneratorInitializationContext context) {
-            // No initialization required for this one
+        public void Initialize(IncrementalGeneratorInitializationContext context) {
+            var types = context.SyntaxProvider.ForAttributeWithMetadataName(
+                $"DecoratorGenerator.{nameof(DecorateAttribute)}",
+                predicate: IsSyntaxTargetForGeneration,
+                transform: GetSemanticTargetForGeneration
+            );
+
+            context.RegisterSourceOutput(types, Execute);
         }
 
-        public void Execute(GeneratorExecutionContext context) {
-            var types = GetAllDecoratedTypes(context.Compilation.Assembly.GlobalNamespace);
-
-            var wrapperSymbolWithoutNamespace = context.Compilation.Assembly.GetTypeByMetadataName("WrapperList");
-            var wrapperListTypes =
-                (wrapperSymbolWithoutNamespace == null)
-                ? GetAllTypes(context.Compilation.Assembly.GlobalNamespace, x => x.Name == "WrapperList")
-                : new[] { wrapperSymbolWithoutNamespace };
-            var thirdPartyTypes =
-                wrapperListTypes.SelectMany(x => x.GetMembers()
-                .Where(m => m.Name != ".ctor")
-                .Select(m => m as IFieldSymbol)
-                .Select(f => f.Type)
-                .Select(t => t as INamedTypeSymbol));
-
-            types = types.Concat(thirdPartyTypes);
-
-            var outputs = types.Select(OutputGenerator.GenerateOutputs);
-
-            foreach (var (source, className) in outputs) {
-                // Add the source code to the compilation
-                context.AddSource($"{className}.generated.cs", SourceText.From(source, Encoding.UTF8, SourceHashAlgorithm.Sha256));
-            }
+        private static bool IsSyntaxTargetForGeneration(SyntaxNode syntaxNode, CancellationToken token) {
+            return syntaxNode is InterfaceDeclarationSyntax;
         }
 
-        /// <summary>
-        /// Gets all Types inside the namespace matching the predicate including nested namespaces.
-        /// </summary>
-        /// <param name="input"></param>
-        /// <param name="predicate"></param>
-        /// <returns></returns>
-        private IEnumerable<INamedTypeSymbol> GetAllTypes(INamespaceSymbol input, Func<INamedTypeSymbol, bool> predicate) {
-            foreach (var space in input.GetNamespaceMembers()) {
-                foreach (var item in space.GetTypeMembers()) {
-                    if (predicate(item)) {
-                        yield return item;
-                    }
-                }
+        private static INamedTypeSymbol GetSemanticTargetForGeneration(GeneratorAttributeSyntaxContext context, CancellationToken cancellationToken) {
+            var intefaceSyntax = context.TargetNode as InterfaceDeclarationSyntax;
+            var symbol = context.SemanticModel.GetDeclaredSymbol(intefaceSyntax, cancellationToken: cancellationToken) as INamedTypeSymbol;
 
-                foreach (var nestedItem in GetAllTypes(space, predicate)) {
-                    yield return nestedItem;
-                }
-            }
+            return symbol;
         }
 
-        /// <summary>
-        /// Gets all Types in the namespace decorated with the <see cref="DecorateAttribute"/> including nested namespaces.
-        /// </summary>
-        /// <param name="input"></param>
-        /// <returns></returns>
-        private IEnumerable<INamedTypeSymbol> GetAllDecoratedTypes(INamespaceSymbol input) {
-            return GetAllTypes(input, (x) => x.GetAttributes().Any(att => att.AttributeClass.Name == nameof(DecorateAttribute)));
+        private static void Execute(SourceProductionContext context, INamedTypeSymbol typeSymbol) {
+            var (source, className) = OutputGenerator.GenerateOutputs(typeSymbol);
+
+            context.AddSource($"{className}.generated.cs", SourceText.From(source, Encoding.UTF8, SourceHashAlgorithm.Sha256));
         }
     }
 }