Merge branch 'main' into intermediate-nodes

Author: DustinCampbell

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs

@@ -11,7 +11,6 @@
 using System.Text;
 using Microsoft.AspNetCore.Razor.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
-using static System.StringExtensions;
 
 namespace Microsoft.AspNetCore.Razor.Language.CodeGeneration;
 
@@ -508,7 +507,7 @@ public override string ReadToEnd()
                 return string.Empty;
             }
 
-            var result = CreateString(_remainingLength, (_page, _chunkIndex, _charIndex), static (destination, state) =>
+            var result = string.Create(_remainingLength, (_page, _chunkIndex, _charIndex), static (destination, state) =>
             {
                 var (page, chunkIndex, charIndex) = state;
 

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorProjectFileSystem.cs

@@ -127,7 +127,7 @@ protected override string NormalizeAndEnsureValidPath(string path)
         var needsSlash = Root[^1] is not '/' && normalizedPath[0] is not '/';
         var length = Root.Length + normalizedPath.Length + (needsSlash ? 1 : 0);
 
-        return StringExtensions.CreateString(
+        return string.Create(
             length,
             state: (Root, normalizedPath, needsSlash),
             static (span, state) =>

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/HtmlTokenizer.cs

@@ -1,8 +1,8 @@
-// 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
-
+using System.Collections.Frozen;
+using System.Collections.Generic;
 using System.Diagnostics;
 using Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax;
 using Microsoft.CodeAnalysis.CSharp;
@@ -14,6 +14,21 @@ namespace Microsoft.AspNetCore.Razor.Language.Legacy;
 // Tokenizer _loosely_ based on http://dev.w3.org/html5/spec/Overview.html#tokenization
 internal class HtmlTokenizer : Tokenizer
 {
+    private static readonly FrozenDictionary<SyntaxKind, SyntaxToken> s_kindToTokenMap = new Dictionary<SyntaxKind, SyntaxToken>()
+    {
+        [SyntaxKind.OpenAngle] = SyntaxFactory.Token(SyntaxKind.OpenAngle, "<"),
+        [SyntaxKind.Bang] = SyntaxFactory.Token(SyntaxKind.Bang, "!"),
+        [SyntaxKind.ForwardSlash] = SyntaxFactory.Token(SyntaxKind.ForwardSlash, "/"),
+        [SyntaxKind.QuestionMark] = SyntaxFactory.Token(SyntaxKind.QuestionMark, "?"),
+        [SyntaxKind.LeftBracket] = SyntaxFactory.Token(SyntaxKind.LeftBracket, "["),
+        [SyntaxKind.CloseAngle] = SyntaxFactory.Token(SyntaxKind.CloseAngle, ">"),
+        [SyntaxKind.RightBracket] = SyntaxFactory.Token(SyntaxKind.RightBracket, "]"),
+        [SyntaxKind.Equals] = SyntaxFactory.Token(SyntaxKind.Equals, "="),
+        [SyntaxKind.DoubleQuote] = SyntaxFactory.Token(SyntaxKind.DoubleQuote, "\""),
+        [SyntaxKind.SingleQuote] = SyntaxFactory.Token(SyntaxKind.SingleQuote, "'"),
+        [SyntaxKind.DoubleHyphen] = SyntaxFactory.Token(SyntaxKind.DoubleHyphen, "--"),
+    }.ToFrozenDictionary();
+
     public HtmlTokenizer(SeekableTextReader source)
         : base(source)
     {
@@ -24,23 +39,20 @@ public HtmlTokenizer(SeekableTextReader source)
 
     private new HtmlTokenizerState? CurrentState => (HtmlTokenizerState?)base.CurrentState;
 
-    public override SyntaxKind RazorCommentKind
-    {
-        get { return SyntaxKind.RazorCommentLiteral; }
-    }
+    public override SyntaxKind RazorCommentKind => SyntaxKind.RazorCommentLiteral;
 
-    public override SyntaxKind RazorCommentTransitionKind
-    {
-        get { return SyntaxKind.RazorCommentTransition; }
-    }
+    public override SyntaxKind RazorCommentTransitionKind => SyntaxKind.RazorCommentTransition;
 
-    public override SyntaxKind RazorCommentStarKind
-    {
-        get { return SyntaxKind.RazorCommentStar; }
-    }
+    public override SyntaxKind RazorCommentStarKind => SyntaxKind.RazorCommentStar;
 
     protected override SyntaxToken CreateToken(string content, SyntaxKind type, RazorDiagnostic[] errors)
     {
+        if (errors.Length == 0 && s_kindToTokenMap.TryGetValue(type, out var token))
+        {
+            Debug.Assert(token.Content == content);
+            return token;
+        }
+
         return SyntaxFactory.Token(type, content, errors);
     }
 
@@ -62,9 +74,10 @@ protected override StateResult Dispatch()
                 return StarAfterRazorCommentBody();
             case HtmlTokenizerState.AtTokenAfterRazorCommentBody:
                 return AtTokenAfterRazorCommentBody(nextState: StartState);
+
             default:
                 Debug.Fail("Invalid TokenizerState");
-                return default(StateResult);
+                return default;
         }
     }
 
@@ -98,20 +111,22 @@ protected override string GetTokenContent(SyntaxKind type)
                 case SyntaxKind.SingleQuote:
                     return "'";
                 case SyntaxKind.Whitespace:
-                    if (Buffer[0] == ' ')
-                    {
-                        return " ";
-                    }
-                    if (Buffer[0] == '\t')
+                    switch (Buffer[0])
                     {
-                        return "\t";
+                        case ' ':
+                            return " ";
+                        case '\t':
+                            return "\t";
                     }
+
                     break;
+
                 case SyntaxKind.NewLine:
                     if (Buffer[0] == '\n')
                     {
                         return "\n";
                     }
+
                     break;
             }
         }
@@ -196,11 +211,13 @@ private StateResult Text()
         return Transition(HtmlTokenizerState.Data, EndToken(SyntaxKind.Text));
     }
 
-    private SyntaxToken Token()
+    private SyntaxToken? Token()
     {
         Debug.Assert(AtToken());
+
         var sym = CurrentCharacter;
         TakeCurrent();
+
         switch (sym)
         {
             case '<':
@@ -227,66 +244,52 @@ private SyntaxToken Token()
                 Debug.Assert(CurrentCharacter == '-');
                 TakeCurrent();
                 return EndToken(SyntaxKind.DoubleHyphen);
+
             default:
                 Debug.Fail("Unexpected token!");
                 return EndToken(SyntaxKind.Marker);
         }
     }
 
-    private SyntaxToken Whitespace()
+    private SyntaxToken? Whitespace()
     {
         while (SyntaxFacts.IsWhitespace(CurrentCharacter))
         {
             TakeCurrent();
         }
+
         return EndToken(SyntaxKind.Whitespace);
     }
 
-    private SyntaxToken Newline()
+    private SyntaxToken? Newline()
     {
         Debug.Assert(SyntaxFacts.IsNewLine(CurrentCharacter));
+
         // CSharp Spec §2.3.1
         var checkTwoCharNewline = CurrentCharacter == '\r';
         TakeCurrent();
+
         if (checkTwoCharNewline && CurrentCharacter == '\n')
         {
             TakeCurrent();
         }
+
         return EndToken(SyntaxKind.NewLine);
     }
 
     private bool AtToken()
-    {
-        switch (CurrentCharacter)
+        => CurrentCharacter switch
         {
-            case '<':
-            case '!':
-            case '/':
-            case '?':
-            case '[':
-            case '>':
-            case ']':
-            case '=':
-            case '"':
-            case '\'':
-            case '@':
-                return true;
-            case '-':
-                return Peek() == '-';
-        }
-
-        return false;
-    }
+            '<' or '!' or '/' or '?' or '[' or '>' or ']' or '=' or '"' or '\'' or '@' => true,
+            '-' => Peek() == '-',
+            _ => false,
+        };
 
     private StateResult Transition(HtmlTokenizerState state)
-    {
-        return Transition((int)state, result: null);
-    }
+        => Transition((int)state, result: null);
 
-    private StateResult Transition(HtmlTokenizerState state, SyntaxToken result)
-    {
-        return Transition((int)state, result);
-    }
+    private StateResult Transition(HtmlTokenizerState state, SyntaxToken? result)
+        => Transition((int)state, result);
 
     private enum HtmlTokenizerState
     {

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/RazorProjectFileSystem.cs

@@ -120,7 +120,7 @@ internal ImmutableArray<RazorProjectItem> FindHierarchicalItems(string basePath,
         {
             pathMemory = pathMemory[..(index + 1)];
 
-            var itemPath = StringExtensions.CreateString(
+            var itemPath = string.Create(
                 length: pathMemory.Length + fileName.Length,
                 state: (pathMemory, fileName),
                 static (span, state) =>

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.cs

@@ -5,7 +5,6 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using Microsoft.AspNetCore.Razor;
-using static System.StringExtensions;
 
 namespace Microsoft.CodeAnalysis.Razor.Logging;
 
@@ -23,7 +22,7 @@ public static string FormatMessage(string message, string categoryName, Exceptio
                 ref messageLineRangeBuilder, ref exceptionLineRangeBuilder);
 
             // Create the final string.
-            return CreateString(state.Length, state, static (span, state) =>
+            return string.Create(state.Length, state, static (span, state) =>
             {
                 Write(state.CategoryNamePart, ref span);
 

src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LspEditorFeatureDetector.cs

@@ -86,16 +86,7 @@ public bool IsLspEditorEnabled()
 #pragma warning restore VSTHRD108 // Assert thread affinity unconditionally
         }
 
-        var useLegacyEditorEnabled = _lazyLegacyEditorEnabled.GetValue(_disposeTokenSource.Token);
-
-        if (useLegacyEditorEnabled)
-        {
-            _activityLog.LogInfo("Using legacy editor because the option was set to true");
-            return false;
-        }
-
-        _activityLog.LogInfo("LSP editor is enabled.");
-        return true;
+        return !_lazyLegacyEditorEnabled.GetValue(_disposeTokenSource.Token);
     }
 
     /// <inheritdoc/>

src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs

@@ -555,6 +555,7 @@ public static bool EndsWith(this string text, char value)
 #endif
     }
 
+#if !NET
     /// <summary>
     ///  Encapsulates a method that receives a span of objects of type <typeparamref name="T"/>
     ///  and a state object of type <typeparamref name="TArg"/>.
@@ -573,49 +574,49 @@ public static bool EndsWith(this string text, char value)
     /// </param>
     public delegate void SpanAction<T, in TArg>(Span<T> span, TArg arg);
 
-    /// <summary>
-    ///  Creates a new string with a specific length and initializes it after creation by using the specified callback.
-    /// </summary>
-    /// <typeparam name="TState">
-    ///  The type of the element to pass to <paramref name="action"/>.
-    /// </typeparam>
-    /// <param name="length">
-    ///  The length of the string to create.
-    /// </param>
-    /// <param name="state">
-    ///  The element to pass to <paramref name="action"/>.
-    /// </param>
-    /// <param name="action">
-    ///  A callback to initialize the string
-    /// </param>
-    /// <returns>
-    ///  The created string.
-    /// </returns>
-    /// <remarks>
-    ///  The initial content of the destination span passed to <paramref name="action"/> is undefined.
-    ///  Therefore, it is the delegate's responsibility to ensure that every element of the span is assigned.
-    ///  Otherwise, the resulting string could contain random characters
-    /// </remarks>
-    public unsafe static string CreateString<TState>(int length, TState state, SpanAction<char, TState> action)
+    extension(string)
     {
-#if NET
-        return string.Create(length, (action, state), static (span, state) => state.action(span, state.state));
-#else
-        ArgHelper.ThrowIfNegative(length);
-
-        if (length == 0)
+        /// <summary>
+        ///  Creates a new string with a specific length and initializes it after creation by using the specified callback.
+        /// </summary>
+        /// <typeparam name="TState">
+        ///  The type of the element to pass to <paramref name="action"/>.
+        /// </typeparam>
+        /// <param name="length">
+        ///  The length of the string to create.
+        /// </param>
+        /// <param name="state">
+        ///  The element to pass to <paramref name="action"/>.
+        /// </param>
+        /// <param name="action">
+        ///  A callback to initialize the string
+        /// </param>
+        /// <returns>
+        ///  The created string.
+        /// </returns>
+        /// <remarks>
+        ///  The initial content of the destination span passed to <paramref name="action"/> is undefined.
+        ///  Therefore, it is the delegate's responsibility to ensure that every element of the span is assigned.
+        ///  Otherwise, the resulting string could contain random characters.
+        /// </remarks>
+        public unsafe static string Create<TState>(int length, TState state, SpanAction<char, TState> action)
         {
-            return string.Empty;
-        }
+            ArgHelper.ThrowIfNegative(length);
 
-        var result = new string('\0', length);
+            if (length == 0)
+            {
+                return string.Empty;
+            }
 
-        fixed (char* ptr = result)
-        {
-            action(new Span<char>(ptr, length), state);
-        }
+            var result = new string('\0', length);
 
-        return result;
-#endif
+            fixed (char* ptr = result)
+            {
+                action(new Span<char>(ptr, length), state);
+            }
+
+            return result;
+        }
     }
+#endif
 }