Perf/generator

src/Compiler/Microsoft.AspNetCore.Razor.Language/src/DefaultRazorTagHelperContextDiscoveryPhase.cs

@@ -17,7 +17,7 @@ internal sealed class DefaultRazorTagHelperContextDiscoveryPhase : RazorEnginePh
 {
     protected override void ExecuteCore(RazorCodeDocument codeDocument)
     {
-        var syntaxTree = codeDocument.GetSyntaxTree();
+        var syntaxTree = codeDocument.GetPreTagHelperSyntaxTree() ?? codeDocument.GetSyntaxTree();
         ThrowForMissingDocumentDependency(syntaxTree);
 
         var descriptors = codeDocument.GetTagHelpers();
@@ -69,7 +69,6 @@ protected override void ExecuteCore(RazorCodeDocument codeDocument)
 
         var context = TagHelperDocumentContext.Create(tagHelperPrefix, descriptors);
         codeDocument.SetTagHelperContext(context);
-        codeDocument.SetPreTagHelperSyntaxTree(syntaxTree);
     }
 
     private static bool MatchesDirective(TagHelperDescriptor descriptor, string typePattern, string assemblyName)

src/Compiler/Microsoft.AspNetCore.Razor.Language/src/DefaultRazorTagHelperRewritePhase.cs

@@ -2,24 +2,27 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 #nullable enable
 
+using System.Collections.Generic;
 using Microsoft.AspNetCore.Razor.Language.Legacy;
 
 namespace Microsoft.AspNetCore.Razor.Language;
 internal sealed class DefaultRazorTagHelperRewritePhase : RazorEnginePhaseBase
 {
     protected override void ExecuteCore(RazorCodeDocument codeDocument)
     {
-        var syntaxTree = codeDocument.GetPreTagHelperSyntaxTree();
+        var syntaxTree = codeDocument.GetPreTagHelperSyntaxTree() ?? codeDocument.GetSyntaxTree();
+        ThrowForMissingDocumentDependency(syntaxTree);
+
         var context = codeDocument.GetTagHelperContext();
-        if (syntaxTree is null || context.TagHelpers.Count == 0)
+        if (context?.TagHelpers.Count > 0)
         {
-            // No descriptors, no-op.
-            return;
+            var rewrittenSyntaxTree = TagHelperParseTreeRewriter.Rewrite(syntaxTree, context.Prefix, context.TagHelpers, out var usedHelpers);
+            codeDocument.SetSyntaxTree(rewrittenSyntaxTree);
+            codeDocument.SetReferencedTagHelpers(usedHelpers);
+        }
+        else
+        {
+            codeDocument.SetReferencedTagHelpers(new HashSet<TagHelperDescriptor>());
         }
-
-        var rewrittenSyntaxTree = TagHelperParseTreeRewriter.Rewrite(syntaxTree, context.Prefix, context.TagHelpers, out var usedHelpers);
-
-        codeDocument.SetReferencedTagHelpers(usedHelpers);
-        codeDocument.SetSyntaxTree(rewrittenSyntaxTree);
     }
 }

src/Compiler/Microsoft.CodeAnalysis.Razor/src/DefaultTagHelperDescriptorFactory.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 #nullable disable

src/Compiler/Microsoft.CodeAnalysis.Razor/src/SymbolExtensions.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;

src/Compiler/Microsoft.NET.Sdk.Razor.SourceGenerators/RazorSourceGenerator.Helpers.cs

@@ -83,8 +83,7 @@ private static RazorProjectEngine GetDiscoveryProjectEngine(
             return discoveryProjectEngine;
         }
 
-        private static RazorProjectEngine GetGenerationProjectEngine(
-            IReadOnlyList<TagHelperDescriptor> tagHelpers,
+        private static SourceGeneratorProjectEngine GetGenerationProjectEngine(
             SourceGeneratorProjectItem item,
             IEnumerable<SourceGeneratorProjectItem> imports,
             RazorSourceGenerationOptions razorSourceGeneratorOptions)
@@ -96,7 +95,7 @@ private static RazorProjectEngine GetGenerationProjectEngine(
                 fileSystem.Add(import);
             }
 
-            var projectEngine = RazorProjectEngine.Create(razorSourceGeneratorOptions.Configuration, fileSystem, b =>
+            var projectEngine = (DefaultRazorProjectEngine)RazorProjectEngine.Create(razorSourceGeneratorOptions.Configuration, fileSystem, b =>
             {
                 b.Features.Add(new DefaultTypeNameFeature());
                 b.SetRootNamespace(razorSourceGeneratorOptions.RootNamespace);
@@ -107,16 +106,13 @@ private static RazorProjectEngine GetGenerationProjectEngine(
                     options.SupportLocalizedComponentNames = razorSourceGeneratorOptions.SupportLocalizedComponentNames;
                 }));
 
-                b.Features.Add(new StaticTagHelperFeature { TagHelpers = tagHelpers });
-                b.Features.Add(new DefaultTagHelperDescriptorProvider());
-
                 CompilerFeatures.Register(b);
                 RazorExtensions.Register(b);
 
                 b.SetCSharpLanguageVersion(razorSourceGeneratorOptions.CSharpLanguageVersion);
             });
 
-            return projectEngine;
+            return new SourceGeneratorProjectEngine(projectEngine);
         }
     }
 }

src/Compiler/Microsoft.NET.Sdk.Razor.SourceGenerators/RazorSourceGenerator.cs

@@ -9,6 +9,7 @@
 using Microsoft.AspNetCore.Razor.Language;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Microsoft.NET.Sdk.Razor.SourceGenerators
 {
@@ -66,69 +67,80 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             var generatedDeclarationCode = componentFiles
                 .Combine(importFiles.Collect())
                 .Combine(razorSourceGeneratorOptions)
+                .WithLambdaComparer((old, @new) => (old.Right.Equals(@new.Right) && old.Left.Left.Equals(@new.Left.Left) && old.Left.Right.SequenceEqual(@new.Left.Right)), (a) => a.GetHashCode())
                 .Select(static (pair, _) =>
                 {
 
                     var ((sourceItem, importFiles), razorSourceGeneratorOptions) = pair;
-                    RazorSourceGeneratorEventSource.Log.GenerateDeclarationCodeStart(sourceItem.FilePath);
+                    RazorSourceGeneratorEventSource.Log.GenerateDeclarationCodeStart(sourceItem.RelativePhysicalPath);
 
                     var projectEngine = GetDeclarationProjectEngine(sourceItem, importFiles, razorSourceGeneratorOptions);
 
                     var codeGen = projectEngine.Process(sourceItem);
 
                     var result = codeGen.GetCSharpDocument().GeneratedCode;
 
-                    RazorSourceGeneratorEventSource.Log.GenerateDeclarationCodeStop(sourceItem.FilePath);
+                    RazorSourceGeneratorEventSource.Log.GenerateDeclarationCodeStop(sourceItem.RelativePhysicalPath);
 
-                    return result;
+                    return (result, sourceItem.RelativePhysicalPath);
                 });
 
             var generatedDeclarationSyntaxTrees = generatedDeclarationCode
                 .Combine(parseOptions)
                 .Select(static (pair, _) =>
                 {
-                    var (generatedDeclarationCode, parseOptions) = pair;
-                    return CSharpSyntaxTree.ParseText(generatedDeclarationCode, (CSharpParseOptions)parseOptions);
+                    var ((generatedDeclarationCode, filePath), parseOptions) = pair;
+                    return CSharpSyntaxTree.ParseText(generatedDeclarationCode, (CSharpParseOptions)parseOptions, filePath);
                 });
 
-            var tagHelpersFromCompilation = compilation
-                .Combine(generatedDeclarationSyntaxTrees.Collect())
+            var tagHelpersFromComponents = generatedDeclarationSyntaxTrees
+                .Combine(compilation)
                 .Combine(razorSourceGeneratorOptions)
-                .Select(static (pair, _) =>
+                .SelectMany(static (pair, ct) =>
                 {
-                    RazorSourceGeneratorEventSource.Log.DiscoverTagHelpersFromCompilationStart();
 
-                    var ((compilation, generatedDeclarationSyntaxTrees), razorSourceGeneratorOptions) = pair;
+                    var ((generatedDeclarationSyntaxTree, compilation), razorSourceGeneratorOptions) = pair;
+                    RazorSourceGeneratorEventSource.Log.DiscoverTagHelpersFromComponentStart(generatedDeclarationSyntaxTree.FilePath);
 
                     var tagHelperFeature = new StaticCompilationTagHelperFeature();
                     var discoveryProjectEngine = GetDiscoveryProjectEngine(compilation.References.ToImmutableArray(), tagHelperFeature);
 
-                    var compilationWithDeclarations = compilation.AddSyntaxTrees(generatedDeclarationSyntaxTrees);
+                    var compilationWithDeclarations = compilation.AddSyntaxTrees(generatedDeclarationSyntaxTree);
+
+                    // try and find the specific root class this component is declaring, falling back to the assembly if for any reason the code is not in the shape we expect
+                    ISymbol targetSymbol = compilationWithDeclarations.Assembly;
+                    var root = generatedDeclarationSyntaxTree.GetRoot(ct);
+                    if (root is CompilationUnitSyntax { Members: [NamespaceDeclarationSyntax { Members: [ClassDeclarationSyntax classSyntax, ..] }, ..] })
+                    {
+                        targetSymbol = compilationWithDeclarations.GetSemanticModel(generatedDeclarationSyntaxTree).GetDeclaredSymbol(classSyntax, ct) ?? targetSymbol;
+                    }
 
                     tagHelperFeature.Compilation = compilationWithDeclarations;
-                    tagHelperFeature.TargetSymbol = compilationWithDeclarations.Assembly;
+                    tagHelperFeature.TargetSymbol = targetSymbol;
 
                     var result = (IList<TagHelperDescriptor>)tagHelperFeature.GetDescriptors();
-                    RazorSourceGeneratorEventSource.Log.DiscoverTagHelpersFromCompilationStop();
+                    RazorSourceGeneratorEventSource.Log.DiscoverTagHelpersFromComponentStop(generatedDeclarationSyntaxTree.FilePath);
                     return result;
-                })
-                .WithLambdaComparer(static (a, b) =>
+                });
+
+            var tagHelpersFromCompilation = compilation
+                .Combine(razorSourceGeneratorOptions)
+                .Select(static (pair, _) =>
                 {
-                    if (a.Count != b.Count)
-                    {
-                        return false;
-                    }
+                    RazorSourceGeneratorEventSource.Log.DiscoverTagHelpersFromCompilationStart();
 
-                    for (var i = 0; i < a.Count; i++)
-                    {
-                        if (!a[i].Equals(b[i]))
-                        {
-                            return false;
-                        }
-                    }
+                    var (compilation, razorSourceGeneratorOptions) = pair;
 
-                    return true;
-                }, getHashCode: static a => a.Count);
+                    var tagHelperFeature = new StaticCompilationTagHelperFeature();
+                    var discoveryProjectEngine = GetDiscoveryProjectEngine(compilation.References.ToImmutableArray(), tagHelperFeature);
+
+                    tagHelperFeature.Compilation = compilation;
+                    tagHelperFeature.TargetSymbol = compilation.Assembly;
+
+                    var result = (IList<TagHelperDescriptor>)tagHelperFeature.GetDescriptors();
+                    RazorSourceGeneratorEventSource.Log.DiscoverTagHelpersFromCompilationStop();
+                    return result;
+                });
 
             var tagHelpersFromReferences = compilation
                 .Combine(razorSourceGeneratorOptions)
@@ -186,12 +198,13 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     return (ICollection<TagHelperDescriptor>)descriptors;
                 });
 
-            var allTagHelpers = tagHelpersFromCompilation
+            var allTagHelpers = tagHelpersFromComponents.Collect()
+                .Combine(tagHelpersFromCompilation)
                 .Combine(tagHelpersFromReferences)
                 .Select(static (pair, _) =>
                 {
-                    var (tagHelpersFromCompilation, tagHelpersFromReferences) = pair;
-                    var count = tagHelpersFromCompilation.Count + tagHelpersFromReferences.Count;
+                    var ((tagHelpersFromComponents, tagHelpersFromCompilation), tagHelpersFromReferences) = pair;
+                    var count = tagHelpersFromCompilation.Count + tagHelpersFromReferences.Count + tagHelpersFromComponents.Length;
                     if (count == 0)
                     {
                         return Array.Empty<TagHelperDescriptor>();
@@ -200,30 +213,66 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     var allTagHelpers = new TagHelperDescriptor[count];
                     tagHelpersFromCompilation.CopyTo(allTagHelpers, 0);
                     tagHelpersFromReferences.CopyTo(allTagHelpers, tagHelpersFromCompilation.Count);
+                    tagHelpersFromComponents.CopyTo(allTagHelpers, tagHelpersFromCompilation.Count + tagHelpersFromReferences.Count);
 
                     return allTagHelpers;
                 });
 
             var generatedOutput = sourceItems
                 .Combine(importFiles.Collect())
-                .Combine(allTagHelpers)
+                .WithLambdaComparer((old, @new) => old.Left.Equals(@new.Left) && old.Right.SequenceEqual(@new.Right), (a) => a.GetHashCode())
                 .Combine(razorSourceGeneratorOptions)
                 .Select(static (pair, _) =>
                 {
-                    var (((sourceItem, imports), allTagHelpers), razorSourceGeneratorOptions) = pair;
+                    var ((sourceItem, imports), razorSourceGeneratorOptions) = pair;
 
-                    RazorSourceGeneratorEventSource.Log.RazorCodeGenerateStart(sourceItem.FilePath);
+                    RazorSourceGeneratorEventSource.Log.ParseRazorDocumentStart(sourceItem.RelativePhysicalPath);
 
-                    // Add a generated suffix so tools, such as coverlet, consider the file to be generated
-                    var hintName = GetIdentifierFromPath(sourceItem.RelativePhysicalPath) + ".g.cs";
+                    var projectEngine = GetGenerationProjectEngine(sourceItem, imports, razorSourceGeneratorOptions);
 
-                    var projectEngine = GetGenerationProjectEngine(allTagHelpers, sourceItem, imports, razorSourceGeneratorOptions);
+                    var document = projectEngine.ProcessInitialParse(sourceItem);
 
-                    var codeDocument = projectEngine.Process(sourceItem);
-                    var csharpDocument = codeDocument.GetCSharpDocument();
+                    RazorSourceGeneratorEventSource.Log.ParseRazorDocumentStop(sourceItem.RelativePhysicalPath);
+                    return (projectEngine, sourceItem.RelativePhysicalPath, document);
+                })
+
+                // Add the tag helpers in, but ignore if they've changed or not, only reprocessing the actual document changed
+                .Combine(allTagHelpers)
+                .WithLambdaComparer((old, @new) => old.Left.Equals(@new.Left), (item) => item.GetHashCode())
+                .Select((pair, _) =>
+                {
+                    var ((projectEngine, filePath, codeDocument), allTagHelpers) = pair;
+                    RazorSourceGeneratorEventSource.Log.RewriteTagHelpersStart(filePath);
+
+                    codeDocument = projectEngine.ProcessTagHelpers(codeDocument, allTagHelpers, checkForIdempotency: false);
 
-                    RazorSourceGeneratorEventSource.Log.RazorCodeGenerateStop(sourceItem.FilePath);
-                    return (hintName, csharpDocument);
+                    RazorSourceGeneratorEventSource.Log.RewriteTagHelpersStop(filePath);
+                    return (projectEngine, filePath, codeDocument);
+                })
+
+                // next we do a second parse, along with the helpers, but check for idempotency. If the tag helpers used on the previous parse match, the compiler can skip re-computing them
+                .Combine(allTagHelpers)
+                .Select((pair, _) =>
+                {
+
+                    var ((projectEngine, filePath, document), allTagHelpers) = pair;
+                    RazorSourceGeneratorEventSource.Log.CheckAndRewriteTagHelpersStart(filePath);
+
+                    document = projectEngine.ProcessTagHelpers(document, allTagHelpers, checkForIdempotency: true);
+
+                    RazorSourceGeneratorEventSource.Log.CheckAndRewriteTagHelpersStop(filePath);
+                    return (projectEngine, filePath, document);
+                })
+
+                .Select((pair, _) =>
+                {
+                    var (projectEngine, filePath, document) = pair;
+                    RazorSourceGeneratorEventSource.Log.RazorCodeGenerateStart(filePath);
+                    document = projectEngine.ProcessRemaining(document);
+                    var csharpDocument = document.CodeDocument.GetCSharpDocument();
+
+                    RazorSourceGeneratorEventSource.Log.RazorCodeGenerateStop(filePath);
+                    return (filePath, csharpDocument);
                 })
                 .WithLambdaComparer(static (a, b) =>
                 {
@@ -238,7 +287,11 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 
             context.RegisterSourceOutput(generatedOutput, static (context, pair) =>
             {
-                var (hintName, csharpDocument) = pair;
+                var (filePath, csharpDocument) = pair;
+
+                // Add a generated suffix so tools, such as coverlet, consider the file to be generated
+                var hintName = GetIdentifierFromPath(filePath) + ".g.cs";
+
                 RazorSourceGeneratorEventSource.Log.AddSyntaxTrees(hintName);
                 for (var i = 0; i < csharpDocument.Diagnostics.Count; i++)
                 {

src/Compiler/Microsoft.NET.Sdk.Razor.SourceGenerators/RazorSourceGeneratorEventSource.cs

@@ -59,5 +59,37 @@ private RazorSourceGeneratorEventSource() { }
         private const int GenerateDeclarationSyntaxTreeStopId = 14;
         [Event(GenerateDeclarationSyntaxTreeStopId, Level = EventLevel.Informational)]
         public void GenerateDeclarationSyntaxTreeStop() => WriteEvent(GenerateDeclarationSyntaxTreeStopId);
+
+        private const int DiscoverTagHelpersFromComponentStartId = 15;
+        [Event(DiscoverTagHelpersFromComponentStartId, Level = EventLevel.Informational)]
+        public void DiscoverTagHelpersFromComponentStart(string filePath) => WriteEvent(DiscoverTagHelpersFromComponentStartId, filePath);
+
+        private const int DiscoverTagHelpersFromComponentStopId = 16;
+        [Event(DiscoverTagHelpersFromComponentStopId, Level = EventLevel.Informational)]
+        public void DiscoverTagHelpersFromComponentStop(string filePath) => WriteEvent(DiscoverTagHelpersFromComponentStopId, filePath);
+
+        private const int ParseRazorDocumentStartId = 17;
+        [Event(ParseRazorDocumentStartId, Level = EventLevel.Informational)]
+        public void ParseRazorDocumentStart(string file) => WriteEvent(ParseRazorDocumentStartId, file);
+
+        private const int ParseRazorDocumentStopId = 18;
+        [Event(ParseRazorDocumentStopId, Level = EventLevel.Informational)]
+        public void ParseRazorDocumentStop(string file) => WriteEvent(ParseRazorDocumentStopId, file);
+
+        private const int RewriteTagHelpersStartId = 19;
+        [Event(RewriteTagHelpersStartId, Level = EventLevel.Informational)]
+        public void RewriteTagHelpersStart(string file) => WriteEvent(RewriteTagHelpersStartId, file);
+
+        private const int RewriteTagHelpersStopId = 20;
+        [Event(RewriteTagHelpersStopId, Level = EventLevel.Informational)]
+        public void RewriteTagHelpersStop(string file) => WriteEvent(RewriteTagHelpersStopId, file);
+
+        private const int CheckAndRewriteTagHelpersStartId = 21;
+        [Event(CheckAndRewriteTagHelpersStartId, Level = EventLevel.Informational)]
+        public void CheckAndRewriteTagHelpersStart(string file) => WriteEvent(CheckAndRewriteTagHelpersStartId, file);
+
+        private const int CheckAndRewriteTagHelpersStopId = 22;
+        [Event(CheckAndRewriteTagHelpersStopId, Level = EventLevel.Informational)]
+        public void CheckAndRewriteTagHelpersStop(string file) => WriteEvent(CheckAndRewriteTagHelpersStopId, file);
     }
 }