New Razor document formatting engine

Directory.Build.props

@@ -44,9 +44,6 @@
     <ExcludeFromSourceOnlyBuild>true</ExcludeFromSourceOnlyBuild>
 
     <DefaultNetFxTargetFramework>net472</DefaultNetFxTargetFramework>
-
-    <!-- Uncomment this line to run formatting on runtime code-gen if FUSE is turned on -->
-    <!-- <DefineConstants>$(DefineConstants);FORMAT_FUSE</DefineConstants> -->
   </PropertyGroup>
 
   <!--

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs

@@ -4,6 +4,8 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using Microsoft.AspNetCore.Razor.Language.Components;
+using Microsoft.AspNetCore.Razor.Language.Extensions;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -29,6 +31,69 @@ internal static bool IsUsingDirective(this SyntaxNode node, out SyntaxList<Synta
         return false;
     }
 
+    internal static bool IsConstrainedTypeParamDirective(this SyntaxNode node, [NotNullWhen(true)] out SyntaxNode? typeParamNode, [NotNullWhen(true)] out SyntaxNode? conditionsNode)
+    {
+        // Returns true for "@typeparam T where T : IDisposable", but not "@typeparam T"
+        if (node is RazorDirectiveSyntax { DirectiveDescriptor: { } descriptor, Body: RazorDirectiveBodySyntax body } &&
+            descriptor.Directive == ComponentConstrainedTypeParamDirective.Directive.Directive &&
+            descriptor.Tokens.Any(t => t.Name == ComponentResources.TypeParamDirective_Constraint_Name) &&
+            // Children is the " T where T : IDisposable" part of the directive
+            body.CSharpCode.Children is [_ /* whitespace */, { } typeParam, _ /* whitespace */, { } conditions, ..])
+        {
+            typeParamNode = typeParam;
+            conditionsNode = conditions;
+            return true;
+        }
+
+        typeParamNode = null;
+        conditionsNode = null;
+        return false;
+    }
+
+    internal static bool IsAttributeDirective(this SyntaxNode node, [NotNullWhen(true)] out SyntaxNode? attributeNode)
+    {
+        if (node is RazorDirectiveSyntax { DirectiveDescriptor: { } descriptor, Body: RazorDirectiveBodySyntax body } &&
+            descriptor.Directive == AttributeDirective.Directive.Directive &&
+            body.CSharpCode.Children is [_, { } attribute, ..])
+        {
+            attributeNode = attribute;
+            return true;
+        }
+
+        attributeNode = null;
+        return false;
+    }
+
+    internal static bool IsCodeDirective(this SyntaxNode node, [NotNullWhen(true)] out SyntaxNode? openBraceNode)
+    {
+        if (node is RazorDirectiveSyntax { DirectiveDescriptor: { } descriptor, Body: RazorDirectiveBodySyntax body } &&
+            descriptor.Directive == ComponentCodeDirective.Directive.Directive &&
+            body.CSharpCode is { Children: { Count: > 0 } children } &&
+            children.TryGetOpenBraceToken(out var openBrace))
+        {
+            openBraceNode = openBrace;
+            return true;
+        }
+
+        openBraceNode = null;
+        return false;
+    }
+
+    internal static bool IsFunctionsDirective(this SyntaxNode node, [NotNullWhen(true)] out SyntaxNode? openBraceNode)
+    {
+        if (node is RazorDirectiveSyntax { DirectiveDescriptor: { } descriptor, Body: RazorDirectiveBodySyntax body } &&
+            descriptor.Directive == FunctionsDirective.Directive.Directive &&
+            body.CSharpCode is { Children: { Count: > 0 } children } &&
+            children.TryGetOpenBraceToken(out var openBrace))
+        {
+            openBraceNode = openBrace;
+            return true;
+        }
+
+        openBraceNode = null;
+        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>

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/SourceTextExtensions.cs

@@ -61,10 +61,19 @@ public static string GetSubTextString(this SourceText text, TextSpan span)
     }
 
     public static bool NonWhitespaceContentEquals(this SourceText text, SourceText other)
+        => NonWhitespaceContentEquals(text, other, 0, text.Length, 0, other.Length);
+
+    public static bool NonWhitespaceContentEquals(
+        this SourceText text,
+        SourceText other,
+        int textStart,
+        int textEnd,
+        int otherStart,
+        int otherEnd)
     {
-        var i = 0;
-        var j = 0;
-        while (i < text.Length && j < other.Length)
+        var i = textStart;
+        var j = otherStart;
+        while (i < textEnd && j < otherEnd)
         {
             if (char.IsWhiteSpace(text[i]))
             {
@@ -85,17 +94,17 @@ public static bool NonWhitespaceContentEquals(this SourceText text, SourceText o
             j++;
         }
 
-        while (i < text.Length && char.IsWhiteSpace(text[i]))
+        while (i < textEnd && char.IsWhiteSpace(text[i]))
         {
             i++;
         }
 
-        while (j < other.Length && char.IsWhiteSpace(other[j]))
+        while (j < otherEnd && char.IsWhiteSpace(other[j]))
         {
             j++;
         }
 
-        return i == text.Length && j == other.Length;
+        return i == textEnd && j == otherEnd;
     }
 
     public static bool TryGetFirstNonWhitespaceOffset(this SourceText text, out int offset)

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/CSharpFormatter.cs

@@ -6,37 +6,21 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.AspNetCore.Razor.Language;
 using Microsoft.AspNetCore.Razor.PooledObjects;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor;
 using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.Razor.DocumentMapping;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 
 namespace Microsoft.CodeAnalysis.Razor.Formatting;
 
-internal sealed class CSharpFormatter(IDocumentMappingService documentMappingService)
+internal sealed class CSharpFormatter
 {
     private const string MarkerId = "RazorMarker";
 
-    private readonly IDocumentMappingService _documentMappingService = documentMappingService;
-
-    public async Task<ImmutableArray<TextChange>> FormatAsync(HostWorkspaceServices hostWorkspaceServices, Document csharpDocument, FormattingContext context, LinePositionSpan spanToFormat, CancellationToken cancellationToken)
-    {
-        if (!_documentMappingService.TryMapToGeneratedDocumentRange(context.CodeDocument.GetCSharpDocument(), spanToFormat, out var projectedSpan))
-        {
-            return [];
-        }
-
-        var edits = await GetFormattingEditsAsync(hostWorkspaceServices, csharpDocument, projectedSpan, context.Options.ToIndentationOptions(), cancellationToken).ConfigureAwait(false);
-        var mappedEdits = MapEditsToHostDocument(context.CodeDocument, edits);
-        return mappedEdits;
-    }
-
     public static async Task<IReadOnlyDictionary<int, int>> GetCSharpIndentationAsync(
         FormattingContext context,
         HashSet<int> projectedDocumentLocations,
@@ -51,24 +35,6 @@ public static async Task<IReadOnlyDictionary<int, int>> GetCSharpIndentationAsyn
         return indentations;
     }
 
-    private ImmutableArray<TextChange> MapEditsToHostDocument(RazorCodeDocument codeDocument, ImmutableArray<TextChange> csharpEdits)
-    {
-        var actualEdits = _documentMappingService.GetHostDocumentEdits(codeDocument.GetCSharpDocument(), csharpEdits);
-
-        return actualEdits.ToImmutableArray();
-    }
-
-    private static async Task<ImmutableArray<TextChange>> GetFormattingEditsAsync(HostWorkspaceServices hostWorkspaceServices, Document csharpDocument, LinePositionSpan projectedSpan, RazorIndentationOptions indentationOptions, CancellationToken cancellationToken)
-    {
-        var root = await csharpDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-        var csharpSourceText = await csharpDocument.GetTextAsync(cancellationToken).ConfigureAwait(false);
-        var spanToFormat = csharpSourceText.GetTextSpan(projectedSpan);
-        Assumes.NotNull(root);
-
-        var changes = RazorCSharpFormattingInteractionService.GetFormattedTextChanges(hostWorkspaceServices, root, spanToFormat, indentationOptions, cancellationToken);
-        return changes.ToImmutableArray();
-    }
-
     private static async Task<Dictionary<int, int>> GetCSharpIndentationCoreAsync(FormattingContext context, ImmutableArray<int> projectedDocumentLocations, HostWorkspaceServices hostWorkspaceServices, CancellationToken cancellationToken)
     {
         // No point calling the C# formatting if we won't be interested in any of its work anyway

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/FormattingContext.cs

@@ -16,10 +16,6 @@
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 
-#if !FORMAT_FUSE
-using Microsoft.CodeAnalysis.Razor.ProjectSystem;
-#endif
-
 namespace Microsoft.CodeAnalysis.Razor.Formatting;
 
 internal sealed class FormattingContext
@@ -228,14 +224,7 @@ public bool TryGetFormattingSpan(int absoluteIndex, [NotNullWhen(true)] out Form
     public async Task<FormattingContext> WithTextAsync(SourceText changedText, CancellationToken cancellationToken)
     {
         var changedSnapshot = OriginalSnapshot.WithText(changedText);
-
-#if !FORMAT_FUSE
-        // Formatting always uses design time document
-        var generator = (IDesignTimeCodeGenerator)changedSnapshot;
-        var codeDocument = await generator.GenerateDesignTimeOutputAsync(cancellationToken).ConfigureAwait(false);
-#else
         var codeDocument = await changedSnapshot.GetGeneratedOutputAsync(cancellationToken).ConfigureAwait(false);
-#endif
 
         DEBUG_ValidateComponents(CodeDocument, codeDocument);
 

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/FormattingUtilities.cs

@@ -4,7 +4,9 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.Linq;
+using Microsoft.AspNetCore.Razor;
 using Microsoft.AspNetCore.Razor.Language;
 using Microsoft.AspNetCore.Razor.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
@@ -120,6 +122,57 @@ public static string AddIndentationToMethod(string method, int tabSize, bool ins
         return AddIndentationToMethod(method, tabSize, insertSpaces, startingIndent);
     }
 
+    public static int CountNonWhitespaceChars(SourceText text, int start, int end)
+    {
+        var count = 0;
+        for (var i = start; i < end; i++)
+        {
+            if (!char.IsWhiteSpace(text[i]))
+            {
+                count++;
+            }
+        }
+
+        return count;
+    }
+
+    public static int GetIndentationLevel(TextLine line, int firstNonWhitespaceCharacterPosition, bool insertSpaces, int tabSize, out string additionalIndentation)
+    {
+        if (firstNonWhitespaceCharacterPosition > line.End)
+        {
+            throw new ArgumentOutOfRangeException(nameof(firstNonWhitespaceCharacterPosition), "The first non-whitespace character position must be within the line.");
+        }
+
+        // For spaces, the actual indentation needs to be divided by the tab size to get the level, and additional is the remainder
+        var indentation = firstNonWhitespaceCharacterPosition - line.Start;
+        if (insertSpaces)
+        {
+            var indent = indentation / tabSize;
+            additionalIndentation = new string(' ', indentation % tabSize);
+            return indent;
+        }
+
+        // For tabs, we just count the tabs, and additional is any spaces at the end.
+        var tabCount = 0;
+        var text = line.Text.AssumeNotNull();
+        for (var i = line.Start; i < firstNonWhitespaceCharacterPosition; i++)
+        {
+            if (text[i] == '\t')
+            {
+                tabCount++;
+            }
+            else
+            {
+                Debug.Assert(text[i] == ' ');
+                additionalIndentation = text.GetSubTextString(TextSpan.FromBounds(i, firstNonWhitespaceCharacterPosition));
+                return tabCount;
+            }
+        }
+
+        additionalIndentation = "";
+        return tabCount;
+    }
+
     /// <summary>
     /// Given a <paramref name="indentation"/> amount of characters, generate a string representing the configured indentation.
     /// </summary>