Polyfill the incremental generator ForAttributeWithMetadataName from roslyn (for LoggingGenerator). (#71651)

CyrusNajmabadi · web-flow · commit 961032035a4b · 2022-07-07T12:02:29.000-07:00
* Polyfill the incremental generator ForAttributeWithMetadataName from roslyn (for LoggingGenerator).

* Simplify

* Fix project file

* Remove

* revert
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Parser.cs
@@ -18,7 +18,7 @@ public partial class LoggerMessageGenerator
     {
         internal sealed class Parser
         {
-            private const string LoggerMessageAttribute = "Microsoft.Extensions.Logging.LoggerMessageAttribute";
+            internal const string LoggerMessageAttribute = "Microsoft.Extensions.Logging.LoggerMessageAttribute";
 
             private readonly CancellationToken _cancellationToken;
             private readonly Compilation _compilation;
@@ -31,36 +31,6 @@ public Parser(Compilation compilation, Action<Diagnostic> reportDiagnostic, Canc
                 _reportDiagnostic = reportDiagnostic;
             }
 
-            internal static bool IsSyntaxTargetForGeneration(SyntaxNode node) =>
-                node is MethodDeclarationSyntax m && m.AttributeLists.Count > 0;
-
-            internal static ClassDeclarationSyntax? GetSemanticTargetForGeneration(GeneratorSyntaxContext context)
-            {
-                var methodDeclarationSyntax = (MethodDeclarationSyntax)context.Node;
-
-                foreach (AttributeListSyntax attributeListSyntax in methodDeclarationSyntax.AttributeLists)
-                {
-                    foreach (AttributeSyntax attributeSyntax in attributeListSyntax.Attributes)
-                    {
-                        IMethodSymbol attributeSymbol = context.SemanticModel.GetSymbolInfo(attributeSyntax).Symbol as IMethodSymbol;
-                        if (attributeSymbol == null)
-                        {
-                            continue;
-                        }
-
-                        INamedTypeSymbol attributeContainingTypeSymbol = attributeSymbol.ContainingType;
-                        string fullName = attributeContainingTypeSymbol.ToDisplayString();
-
-                        if (fullName == LoggerMessageAttribute)
-                        {
-                            return methodDeclarationSyntax.Parent as ClassDeclarationSyntax;
-                        }
-                    }
-                }
-
-                return null;
-            }
-
             /// <summary>
             /// Gets the set of logging classes containing methods to output.
             /// </summary>
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Roslyn3.11.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Roslyn3.11.cs
@@ -49,15 +49,45 @@ internal static ISyntaxContextReceiver Create()
 
             public void OnVisitSyntaxNode(GeneratorSyntaxContext context)
             {
-                if (Parser.IsSyntaxTargetForGeneration(context.Node))
+                if (IsSyntaxTargetForGeneration(context.Node))
                 {
-                    ClassDeclarationSyntax classSyntax = Parser.GetSemanticTargetForGeneration(context);
+                    ClassDeclarationSyntax classSyntax = GetSemanticTargetForGeneration(context);
                     if (classSyntax != null)
                     {
                         ClassDeclarations.Add(classSyntax);
                     }
                 }
             }
+
+            private static bool IsSyntaxTargetForGeneration(SyntaxNode node) =>
+                node is MethodDeclarationSyntax m && m.AttributeLists.Count > 0;
+
+            private static ClassDeclarationSyntax? GetSemanticTargetForGeneration(GeneratorSyntaxContext context)
+            {
+                var methodDeclarationSyntax = (MethodDeclarationSyntax)context.Node;
+
+                foreach (AttributeListSyntax attributeListSyntax in methodDeclarationSyntax.AttributeLists)
+                {
+                    foreach (AttributeSyntax attributeSyntax in attributeListSyntax.Attributes)
+                    {
+                        IMethodSymbol attributeSymbol = context.SemanticModel.GetSymbolInfo(attributeSyntax).Symbol as IMethodSymbol;
+                        if (attributeSymbol == null)
+                        {
+                            continue;
+                        }
+
+                        INamedTypeSymbol attributeContainingTypeSymbol = attributeSymbol.ContainingType;
+                        string fullName = attributeContainingTypeSymbol.ToDisplayString();
+
+                        if (fullName == Parser.LoggerMessageAttribute)
+                        {
+                            return methodDeclarationSyntax.Parent as ClassDeclarationSyntax;
+                        }
+                    }
+                }
+
+                return null;
+            }
         }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Roslyn4.0.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/LoggerMessageGenerator.Roslyn4.0.cs
@@ -7,6 +7,7 @@
 using System.Text;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.DotnetRuntime.Extensions;
 using Microsoft.CodeAnalysis.Text;
 
 [assembly: System.Resources.NeutralResourcesLanguage("en-us")]
@@ -19,7 +20,11 @@ public partial class LoggerMessageGenerator : IIncrementalGenerator
         public void Initialize(IncrementalGeneratorInitializationContext context)
         {
             IncrementalValuesProvider<ClassDeclarationSyntax> classDeclarations = context.SyntaxProvider
-                .CreateSyntaxProvider(static (s, _) => Parser.IsSyntaxTargetForGeneration(s), static (ctx, _) => Parser.GetSemanticTargetForGeneration(ctx))
+                .ForAttributeWithMetadataName(
+                    context,
+                    Parser.LoggerMessageAttribute,
+                    (node, _) => node is MethodDeclarationSyntax,
+                    (context, _) => context.TargetNode.Parent as ClassDeclarationSyntax)
                 .Where(static m => m is not null);
 
             IncrementalValueProvider<(Compilation, ImmutableArray<ClassDeclarationSyntax>)> compilationAndClasses =
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Microsoft.Extensions.Logging.Generators.Roslyn4.0.csproj b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Microsoft.Extensions.Logging.Generators.Roslyn4.0.csproj
@@ -8,6 +8,20 @@
 
   <Import Project="Microsoft.Extensions.Logging.Generators.targets" />
 
+  <ItemGroup>
+    <Compile Include="$(CommonPath)Roslyn\Hash.cs" Link="Common\Roslyn\Hash.cs" />
+    <Compile Include="$(CommonPath)Roslyn\ISyntaxHelper.cs" Link="Common\Roslyn\ISyntaxHelper.cs" />
+    <Compile Include="$(CommonPath)Roslyn\CSharpSyntaxHelper.cs" Link="Common\Roslyn\CSharpSyntaxHelper.cs" />
+    <Compile Include="$(CommonPath)Roslyn\GlobalAliases.cs" Link="Common\Roslyn\GlobalAliases.cs" />
+    <Compile Include="$(CommonPath)Roslyn\SyntaxNodeGrouping.cs" Link="Common\Roslyn\SyntaxNodeGrouping.cs" />
+    <Compile Include="$(CommonPath)Roslyn\SyntaxValueProvider.ImmutableArrayValueComparer.cs" Link="Common\Roslyn\SyntaxValueProvider.ImmutableArrayValueComparer.cs" />
+    <Compile Include="$(CommonPath)Roslyn\SyntaxValueProvider_ForAttributeWithMetadataName.cs" Link="Common\Roslyn\SyntaxValueProvider_ForAttributeWithMetadataName.cs" />
+    <Compile Include="$(CommonPath)Roslyn\SyntaxValueProvider_ForAttributeWithSimpleName.cs" Link="Common\Roslyn\SyntaxValueProvider_ForAttributeWithSimpleName.cs" />
+
+    <Compile Include="$(CoreLibSharedDir)System\Collections\Generic\ValueListBuilder.cs" Link="Production\ValueListBuilder.cs" />
+    <Compile Include="$(CoreLibSharedDir)System\Collections\Generic\ValueListBuilder.Pop.cs" Link="Production\ValueListBuilder.Pop.cs" />
+  </ItemGroup>
+  
   <ItemGroup>
     <Compile Remove="LoggerMessageGenerator.Roslyn3.11.cs" />
   </ItemGroup>

Original file line number	Diff line number	Diff line change
`@@ -49,15 +49,45 @@ internal static ISyntaxContextReceiver Create()`
`49`	`49`
`50`	`50`	`public void OnVisitSyntaxNode(GeneratorSyntaxContext context)`
`51`	`51`	`{`
`52`		`- if (Parser.IsSyntaxTargetForGeneration(context.Node))`
	`52`	`+ if (IsSyntaxTargetForGeneration(context.Node))`
`53`	`53`	`{`
`54`		`- ClassDeclarationSyntax classSyntax = Parser.GetSemanticTargetForGeneration(context);`
	`54`	`+ ClassDeclarationSyntax classSyntax = GetSemanticTargetForGeneration(context);`
`55`	`55`	`if (classSyntax != null)`
`56`	`56`	`{`
`57`	`57`	`ClassDeclarations.Add(classSyntax);`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	`}`
	`61`	`+`
	`62`	`+ private static bool IsSyntaxTargetForGeneration(SyntaxNode node) =>`
	`63`	`+ node is MethodDeclarationSyntax m && m.AttributeLists.Count > 0;`
	`64`	`+`
	`65`	`+ private static ClassDeclarationSyntax? GetSemanticTargetForGeneration(GeneratorSyntaxContext context)`
	`66`	`+ {`
	`67`	`+ var methodDeclarationSyntax = (MethodDeclarationSyntax)context.Node;`
	`68`	`+`
	`69`	`+ foreach (AttributeListSyntax attributeListSyntax in methodDeclarationSyntax.AttributeLists)`
	`70`	`+ {`
	`71`	`+ foreach (AttributeSyntax attributeSyntax in attributeListSyntax.Attributes)`
	`72`	`+ {`
	`73`	`+ IMethodSymbol attributeSymbol = context.SemanticModel.GetSymbolInfo(attributeSyntax).Symbol as IMethodSymbol;`
	`74`	`+ if (attributeSymbol == null)`
	`75`	`+ {`
	`76`	`+ continue;`
	`77`	`+ }`
	`78`	`+`
	`79`	`+ INamedTypeSymbol attributeContainingTypeSymbol = attributeSymbol.ContainingType;`
	`80`	`+ string fullName = attributeContainingTypeSymbol.ToDisplayString();`
	`81`	`+`
	`82`	`+ if (fullName == Parser.LoggerMessageAttribute)`
	`83`	`+ {`
	`84`	`+ return methodDeclarationSyntax.Parent as ClassDeclarationSyntax;`
	`85`	`+ }`
	`86`	`+ }`
	`87`	`+ }`
	`88`	`+`
	`89`	`+ return null;`
	`90`	`+ }`
`61`	`91`	`}`
`62`	`92`	`}`
`63`	`93`	`}`