Merge pull request #8807 from davidwengier/DontUsePreviousSpan

Don't use PreviousSpan method, because it's slow

Author: davidwengier

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Extensions/SyntaxNodeExtensions.cs

@@ -34,6 +34,31 @@ body.Keyword is CSharpStatementLiteralSyntax literal &&
         return false;
     }
 
+    /// <summary>
+    /// Walks up the tree through the <paramref name="owner"/>'s parents to find the outermost node that starts at the same position.
+    /// </summary>
+    internal static SyntaxNode? GetOutermostNode(this SyntaxNode owner)
+    {
+        var node = owner.Parent;
+        if (node is null)
+        {
+            return owner;
+        }
+
+        var lastNode = node;
+        while (node.SpanStart == owner.SpanStart)
+        {
+            lastNode = node;
+            node = node.Parent;
+            if (node is null)
+            {
+                break;
+            }
+        }
+
+        return lastNode;
+    }
+
     internal static bool TryGetPreviousSibling(this SyntaxNode syntaxNode, [NotNullWhen(true)] out SyntaxNode? previousSibling)
     {
         var syntaxNodeParent = syntaxNode.Parent;

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Formatting/CSharpFormattingPassBase.cs

@@ -368,7 +368,7 @@ bool IsImplicitStatementStart()
             if (owner.SpanStart == mappingSpan.Start &&
                 owner is CSharpStatementLiteralSyntax &&
                 owner.Parent is CSharpCodeBlockSyntax &&
-                owner.PreviousSpan() is CSharpTransitionSyntax)
+                owner.TryGetPreviousSibling(out var transition) && transition is CSharpTransitionSyntax)
             {
                 return true;
             }
@@ -487,12 +487,16 @@ private static SyntaxNode FixOwnerToWorkaroundCompilerQuirks(SyntaxNode owner)
         // Workaround for https://github.com/dotnet/aspnetcore/issues/36689
         // A tags owner comes back as itself if it is preceeded by a HTML comment,
         // because the whitespace between the comment and the tag is reported as not editable
-        if (owner is MarkupTextLiteralSyntax &&
-            owner.PreviousSpan() is MarkupTextLiteralSyntax literal &&
-            literal.ContainsOnlyWhitespace() &&
-            literal.PreviousSpan()?.Parent is MarkupCommentBlockSyntax)
+
+        // Get to the outermost node first. eg in "<span" we might be on the node for the "<", which is parented
+        // by some other intermediate node, which is parented by the actual start tag node. We need to get out to
+        // the start tag node, in order to reason about its siblings. The siblings of the "<" are not helpful :)
+        var outerNode = owner.GetOutermostNode();
+        if (outerNode is not null &&
+            outerNode.TryGetPreviousSibling(out var whiteSpace) && whiteSpace.ContainsOnlyWhitespace() &&
+            whiteSpace.TryGetPreviousSibling(out var comment) && comment is MarkupCommentBlockSyntax)
         {
-            owner = literal;
+            return whiteSpace;
         }
 
         return owner;

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Formatting/CSharpOnTypeFormattingPass.cs

@@ -346,7 +346,7 @@ private static void CleanupSourceMappingStart(FormattingContext context, Range s
         }
 
         if (owner is CSharpStatementLiteralSyntax &&
-            owner.PreviousSpan() is { } prevNode &&
+            owner.TryGetPreviousSibling(out var prevNode) &&
             prevNode.AncestorsAndSelf().FirstOrDefault(a => a is CSharpTemplateBlockSyntax) is { } template &&
             owner.SpanStart == template.Span.End &&
             IsOnSingleLine(template, text))