prefer ForAttributeWithMetadataName

GitLinkGenerator/GitPathGenerator.cs

@@ -33,77 +33,56 @@ internal sealed class GitPathAttribute : Attribute
         var gitInfo = context.AnalyzerConfigOptionsProvider.
             Select ( extraGitInfo);
 
-        var classDeclarations = context.SyntaxProvider
-            .CreateSyntaxProvider(
-                predicate: static (s, _) => IsClassWithAttributes(s),
-                transform: static (ctx, _) => GetSemanticTargetForGeneration(ctx))
-            .Where(static m => m is not null);
-
-        var compilationAndClasses = context.CompilationProvider.Combine(classDeclarations.Collect());
-
-        context.RegisterSourceOutput(compilationAndClasses.Combine(gitInfo), static (spc, source) => Execute(source.Left.Left, source.Left.Right, source.Right, spc));
-    }
-    private static (string repository, string branch, string projectUrl)? extraGitInfo(AnalyzerConfigOptionsProvider provider, CancellationToken token)
-    {
-        if(provider.GlobalOptions.TryGetValue("build_property.GitRootDirectory", out var repository)
-        && provider.GlobalOptions.TryGetValue("build_property.GitBranch", out var branch)
-        && provider.GlobalOptions.TryGetValue("build_property.PackageProjectUrl", out var projectUrl))
-        {
-            return (repository, branch, projectUrl);
-        }
-
-        return null;
-    }
-
-    private static bool IsClassWithAttributes(SyntaxNode node)
-    {
-        return node is ClassDeclarationSyntax classDeclarationSyntax && classDeclarationSyntax.AttributeLists.Count > 0;
-    }
-
-    private static ClassDeclarationSyntax GetSemanticTargetForGeneration(GeneratorSyntaxContext context)
-    {
-        var classDeclarationSyntax = (ClassDeclarationSyntax)context.Node;
-        return classDeclarationSyntax;
-    }
-
-    private static void Execute(Compilation compilation, ImmutableArray<ClassDeclarationSyntax> classes, (string repository,string branch, string projectUrl)? gitInfo, SourceProductionContext context)
-    {
-        if (classes.IsDefaultOrEmpty)
-            return;
-
-        var attributeSymbol = compilation.GetTypeByMetadataName("GitPathGenerator.GitPathAttribute");
-        if (attributeSymbol == null)
-            return;
+       var pipeline = context.SyntaxProvider.ForAttributeWithMetadataName(
+            fullyQualifiedMetadataName: "GitPathGenerator.GitPathAttribute",
+            predicate: static (syntaxNode, cancellationToken) => syntaxNode is ClassDeclarationSyntax,
+            transform: static (context, cancellationToken) =>
+            {
+                return new Model(
+                    // Note: this is a simplified example. You will also need to handle the case where the type is in a global namespace, nested, etc.
+                    Namespace: context.TargetSymbol.ContainingNamespace?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat.WithGlobalNamespaceStyle(SymbolDisplayGlobalNamespaceStyle.Omitted)),
+                    ClassName: context.TargetSymbol.Name,
+                    FilePath: context.TargetNode.SyntaxTree.FilePath);
+            }
+        );
 
-        foreach (var classDeclaration in classes)
+        context.RegisterSourceOutput(pipeline.Combine(gitInfo), static (context, args) =>
         {
-            var model = compilation.GetSemanticModel(classDeclaration.SyntaxTree);
-            var classSymbol = model.GetDeclaredSymbol(classDeclaration);
-
-            var attributeData = classSymbol.GetAttributes().FirstOrDefault(ad => ad.AttributeClass.Equals(attributeSymbol, SymbolEqualityComparer.Default));
-            if (attributeData != null)
-            {
+            var gitInfo = args.Right;
+            var model = args.Left;
                 string? filePath = null;
 
                 if(GitHubGenerator.IsGitHub(gitInfo.Value.projectUrl))
                 {
-                    filePath = GitHubGenerator.GitHubGeneratePath(classDeclaration.SyntaxTree.FilePath, gitInfo.Value.projectUrl, gitInfo.Value.branch, gitInfo.Value.repository);
+                    filePath = GitHubGenerator.GitHubGeneratePath(model.FilePath, gitInfo.Value.projectUrl, gitInfo.Value.branch, gitInfo.Value.repository);
                 }
-
 
                 if(filePath != null) {
                     var source = $@"
-                        namespace {classSymbol.ContainingNamespace.ToDisplayString()}
+                        namespace {model.Namespace}
                         {{
-                            public partial class {classSymbol.Name}
+                            public partial class {model.ClassName}
                             {{
                                 public const string GitPath = ""{filePath}"";
                             }}
                         }}";
 
-                context.AddSource($"{classSymbol.Name}_GitPath.cs", SourceText.From(source, Encoding.UTF8));
+                context.AddSource($"{model.ClassName}_GitPath.cs", SourceText.From(source, Encoding.UTF8));
                 }
-            }
+        });
+    }
+
+    private record Model(string? Namespace, string ClassName, string FilePath);
+
+    private static (string repository, string branch, string projectUrl)? extraGitInfo(AnalyzerConfigOptionsProvider provider, CancellationToken token)
+    {
+        if(provider.GlobalOptions.TryGetValue("build_property.GitRootDirectory", out var repository)
+        && provider.GlobalOptions.TryGetValue("build_property.GitBranch", out var branch)
+        && provider.GlobalOptions.TryGetValue("build_property.PackageProjectUrl", out var projectUrl))
+        {
+            return (repository, branch, projectUrl);
         }
+
+        return null;
     }
-}
+}

GitLinkGenerator/IsExternalInit.cs

@@ -0,0 +1,5 @@
+
+namespace System.Runtime.CompilerServices
+    {
+    internal static class IsExternalInit {}
+    }