Handle Html indentation ourselves, rather than using the IDE formatter

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Completion/Delegation/DelegatedCompletionHelper.cs

@@ -255,7 +255,7 @@ static bool IsInScriptOrStyleOrHtmlComment(AspNetCore.Razor.Language.Syntax.Synt
             {
                 if (node is MarkupElementSyntax elementNode)
                 {
-                    if (RazorSyntaxFacts.IsStyleBlock(elementNode) || RazorSyntaxFacts.IsScriptBlock(elementNode))
+                    if (RazorSyntaxFacts.IsScriptOrStyleBlock(elementNode))
                     {
                         return true;
                     }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/HtmlFormattingPass.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
@@ -87,13 +88,26 @@ private async Task<ImmutableArray<TextChange>> FilterIncomingChangesAsync(Format
         var syntaxRoot = codeDocument.GetRequiredSyntaxRoot();
         var sourceText = codeDocument.Source.Text;
         SyntaxNode? csharpSyntaxRoot = null;
+        ImmutableArray<int> scriptAndStyleElementBounds = default;
 
         using var changesToKeep = new PooledArrayBuilder<TextChange>(capacity: changes.Length);
 
         foreach (var change in changes)
         {
-            // We don't keep changes that start inside of a razor comment block.
             var node = syntaxRoot.FindInnermostNode(change.Span.Start);
+
+            // We don't keep indentation changes that aren't in a script or style block
+            // As a quick check, we only care about dropping edits that affect indentation - ie, are before the first
+            // whitespace char on a line
+            var line = sourceText.Lines.GetLineFromPosition(change.Span.Start);
+            if (change.Span.Start < line.GetFirstNonWhitespacePosition() &&
+                !ChangeIsInsideScriptOrStyleElement(change))
+            {
+                context.Logger?.LogMessage($"Dropping change {change} because it's not in a script or style block");
+                continue;
+            }
+
+            // We don't keep changes that start inside of a razor comment block.
             var comment = node?.FirstAncestorOrSelf<RazorCommentBlockSyntax>();
             if (comment is not null && change.Span.Start > comment.SpanStart)
             {
@@ -190,6 +204,60 @@ async Task<bool> ChangeIsInStringLiteralAsync(FormattingContext context, RazorCS
 
             return false;
         }
+
+        bool ChangeIsInsideScriptOrStyleElement(TextChange change)
+        {
+            // Rather than ascend up the tree for every change, and look for script/style elements, we build up an index
+            // first and just reuse it for every subsequent edit.
+            InitializeElementBoundsArray();
+
+            // If there aren't any elements we're interested in, we don't need to do anything
+            if (scriptAndStyleElementBounds.Length == 0)
+            {
+                return false;
+            }
+
+            var index = scriptAndStyleElementBounds.BinarySearch(change.Span.Start);
+
+            // If we got a hit, then we're on the tag itself, which is not inside the tag
+            if (index >= 0)
+            {
+                return false;
+            }
+
+            // If we don't get a hit, the complement of the result is the index to the next largest item in the array. Since we add
+            // things to the array in pairs, we know that if that index is even, we're outside an element, so we want to ignore identation.
+            // This only works if the array is ordered, but we can assume it is because we built it in order, and it makes no sense to nest
+            // script tags within style tags, or vice versa.
+            index = ~index;
+            if (index % 2 == 0)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        void InitializeElementBoundsArray()
+        {
+            if (!scriptAndStyleElementBounds.IsDefault)
+            {
+                return;
+            }
+
+            using var boundsBuilder = new PooledArrayBuilder<int>();
+
+            foreach (var element in syntaxRoot.DescendantNodes(static node => node is RazorDocumentSyntax or MarkupBlockSyntax or MarkupElementSyntax or CSharpCodeBlockSyntax).OfType<MarkupElementSyntax>())
+            {
+                if (RazorSyntaxFacts.IsScriptOrStyleBlock(element))
+                {
+                    boundsBuilder.Add(element.SpanStart);
+                    boundsBuilder.Add(element.Span.End);
+                }
+            }
+
+            scriptAndStyleElementBounds = boundsBuilder.ToImmutableAndClear();
+        }
     }
 
     internal TestAccessor GetTestAccessor() => new(this);

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/RazorSyntaxFacts.cs

@@ -208,18 +208,19 @@ internal static bool IsInUsingDirective(RazorSyntaxNode node)
         return false;
     }
 
-    internal static bool IsElementWithName(MarkupElementSyntax? element, string name)
+    internal static bool IsScriptOrStyleBlock(MarkupElementSyntax? element)
     {
-        return string.Equals(element?.StartTag.Name.Content, name, StringComparison.OrdinalIgnoreCase);
-    }
+        // StartTag is annotated as not nullable, but on invalid documents it can be. The 'Format_DocumentWithDiagnostics' test
+        // illustrates this.
+        if (element?.StartTag?.Name.Content is not { } tagName)
+        {
+            return false;
+        }
 
-    internal static bool IsStyleBlock(MarkupElementSyntax? node)
-    {
-        return IsElementWithName(node, "style");
+        return string.Equals(tagName, "script", StringComparison.OrdinalIgnoreCase) ||
+            string.Equals(tagName, "style", StringComparison.OrdinalIgnoreCase);
     }
 
-    internal static bool IsScriptBlock(MarkupElementSyntax? node)
     {
-        return IsElementWithName(node, "script");
     }
 }