From 32fed2e24ee15f4b04c45c4b5b3bf3fd22a1e21b Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Wed, 17 Jul 2024 15:07:06 -0700
Subject: [PATCH 01/16] Add StringExtensions.CreateString(...) helper

---
 .../StringExtensions.cs                       | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
index 9dde4e4b539..5741c8ea5d8 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
@@ -4,6 +4,7 @@
 using System.Diagnostics.CodeAnalysis;
 
 #if !NET
+using ArgHelper = Microsoft.AspNetCore.Razor.ArgHelper;
 using ThrowHelper = Microsoft.AspNetCore.Razor.Utilities.ThrowHelper;
 #endif
 
@@ -552,6 +553,31 @@ public static bool EndsWith(this string text, char value)
         return text.EndsWith(value);
 #else
         return text.Length > 0 && text[^1] == value;
+#endif
+    }
+
+    public delegate void SpanAction<T, in TArg>(Span<T> span, TArg arg);
+
+    public unsafe static string CreateString<TState>(int length, TState state, SpanAction<char, TState> action)
+    {
+#if NET
+        return string.Create(length, (action, state), (span, state) => state.action(span, state.state));
+#else
+        ArgHelper.ThrowIfNegative(length);
+
+        if (length == 0)
+        {
+            return string.Empty;
+        }
+
+        var result = new string('\0', length);
+
+        fixed (char* ptr = result)
+        {
+            action(new Span<char>(ptr, length), state);
+        }
+
+        return result;
 #endif
     }
 }

From 6f3fcc1a801b6b2d55eb6ad5e8662be8651effb8 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Wed, 17 Jul 2024 15:17:22 -0700
Subject: [PATCH 02/16] Use CreateString helper in CodeWriter

---
 .../src/Language/CodeGeneration/CodeWriter.cs | 49 +++++--------------
 ...crosoft.CodeAnalysis.Razor.Compiler.csproj |  3 +-
 2 files changed, 14 insertions(+), 38 deletions(-)

diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
index b0d4dcae50a..e9f11be5f1c 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
@@ -8,6 +8,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using Microsoft.AspNetCore.Razor.PooledObjects;
+using static System.StringExtensions;
 
 namespace Microsoft.AspNetCore.Razor.Language.CodeGeneration;
 
@@ -259,7 +260,7 @@ public CodeWriter Write([InterpolatedStringHandlerArgument("")] ref WriteInterpo
         => this;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private unsafe CodeWriter WriteCore(ReadOnlyMemory<char> value, bool allowIndent = true)
+    private CodeWriter WriteCore(ReadOnlyMemory<char> value, bool allowIndent = true)
     {
         if (value.IsEmpty)
         {
@@ -336,50 +337,26 @@ public CodeWriter WriteLine([InterpolatedStringHandlerArgument("")] ref WriteInt
 
     public string GenerateCode()
     {
-        unsafe
+        return CreateString(Length, _pages, static (span, pages) =>
         {
-            // This might look a bit scary, but it's pretty simple. We allocate our string
-            // with the correct length up front and then use simple pointer math to copy
-            // the pages of ReadOnlyMemory<char> directly into it.
-
-            // Eventually, we need to remove this and not return a giant string, which can
-            // easily be allocated on the LOH. The work to remove this is tracked by
-            // https://github.com/dotnet/razor/issues/8076.
-
-            var length = Length;
-            var result = new string('\0', length);
-
-            fixed (char* stringPtr = result)
+            foreach (var page in pages)
             {
-                var destination = stringPtr;
-
-                // destinationSize and sourceSize track the number of bytes (not chars).
-                var destinationSize = length * sizeof(char);
-
-                foreach (var page in _pages)
+                foreach (var chars in page)
                 {
-                    foreach (var chars in page)
+                    if (chars.IsEmpty)
                     {
-                        var source = chars.Span;
-                        var sourceSize = source.Length * sizeof(char);
-
-                        fixed (char* srcPtr = source)
-                        {
-                            Buffer.MemoryCopy(srcPtr, destination, destinationSize, sourceSize);
-                        }
+                        return;
+                    }
 
-                        destination += source.Length;
-                        destinationSize -= sourceSize;
+                    chars.Span.CopyTo(span);
+                    span = span[chars.Length..];
 
-                        Debug.Assert(destinationSize >= 0);
-                    }
+                    Debug.Assert(span.Length >= 0);
                 }
-
-                Debug.Assert(destinationSize == 0, "We didn't exhaust our destination pointer!");
             }
 
-            return result;
-        }
+            Debug.Assert(span.Length == 0, "We didn't fill the whole span!");
+        });
     }
 
     public void Dispose()
diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Microsoft.CodeAnalysis.Razor.Compiler.csproj b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Microsoft.CodeAnalysis.Razor.Compiler.csproj
index c98fe2ddf61..deca9b6930d 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Microsoft.CodeAnalysis.Razor.Compiler.csproj
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Microsoft.CodeAnalysis.Razor.Compiler.csproj
@@ -1,10 +1,9 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <Description>Razor is a markup syntax for adding server-side logic to web pages. This package contains the Razor compiler.</Description>
     <TargetFrameworks>$(DefaultNetCoreTargetFramework);netstandard2.0</TargetFrameworks>
     <ExcludeFromSourceBuild>false</ExcludeFromSourceBuild>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
 
     <!--
       RS2008: Enable analyzer release tracking

From 8d9b438270a85c5d68beb157d73758229d0810a0 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Wed, 17 Jul 2024 15:20:49 -0700
Subject: [PATCH 03/16] Use ArgHelper in CodeWriter

---
 .../src/Language/CodeGeneration/CodeWriter.cs | 43 ++++---------------
 1 file changed, 8 insertions(+), 35 deletions(-)

diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
index e9f11be5f1c..96bfcaa31ea 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
@@ -101,10 +101,7 @@ public int CurrentIndent
         get => _indentSize;
         set
         {
-            if (value < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(value));
-            }
+            ArgHelper.ThrowIfNegative(value);
 
             if (_indentSize != value)
             {
@@ -127,10 +124,7 @@ public string NewLine
     [MemberNotNull(nameof(_newLine))]
     private void SetNewLine(string value)
     {
-        if (value == null)
-        {
-            throw new ArgumentNullException(nameof(value));
-        }
+        ArgHelper.ThrowIfNull(value);
 
         if (value != "\r\n" && value != "\n")
         {
@@ -220,10 +214,7 @@ private static ReadOnlyMemory<char> ComputeIndent(int size, bool useTabs, int ta
 
     public CodeWriter Write(string value)
     {
-        if (value == null)
-        {
-            throw new ArgumentNullException(nameof(value));
-        }
+        ArgHelper.ThrowIfNull(value);
 
         return WriteCore(value.AsMemory());
     }
@@ -233,25 +224,10 @@ public CodeWriter Write(ReadOnlyMemory<char> value)
 
     public CodeWriter Write(string value, int startIndex, int count)
     {
-        if (value == null)
-        {
-            throw new ArgumentNullException(nameof(value));
-        }
-
-        if (startIndex < 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(startIndex));
-        }
-
-        if (count < 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(count));
-        }
-
-        if (startIndex > value.Length - count)
-        {
-            throw new ArgumentOutOfRangeException(nameof(startIndex));
-        }
+        ArgHelper.ThrowIfNull(value);
+        ArgHelper.ThrowIfNegative(startIndex);
+        ArgHelper.ThrowIfNegative(count);
+        ArgHelper.ThrowIfGreaterThan(startIndex, value.Length - count);
 
         return WriteCore(value.AsMemory(startIndex, count));
     }
@@ -324,10 +300,7 @@ public CodeWriter WriteLine(ReadOnlyMemory<char> value)
 
     public CodeWriter WriteLine(string value)
     {
-        if (value == null)
-        {
-            throw new ArgumentNullException(nameof(value));
-        }
+        ArgHelper.ThrowIfNull(value);
 
         return WriteCore(value.AsMemory()).WriteLine();
     }

From aed8cfaa5c722f7e9fecfcaf5e8c0ac8067b225f Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Wed, 17 Jul 2024 15:28:12 -0700
Subject: [PATCH 04/16] Add MemoryBuilder<T> helper

---
 .../MemoryBuilder`1.cs                        | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
new file mode 100644
index 00000000000..de2497e5c1e
--- /dev/null
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
@@ -0,0 +1,90 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.AspNetCore.Razor;
+
+/// <summary>
+///  Temporary builder that uses <see cref="ArrayPool{T}"/> to back a <see cref="Memory{T}"/>.
+/// </summary>
+internal ref struct MemoryBuilder<T>
+{
+    private Memory<T> _memory;
+    private T[]? _arrayFromPool;
+    private int _index;
+
+    public MemoryBuilder(int initialCapacity = 1)
+    {
+        ArgHelper.ThrowIfNegativeOrZero(initialCapacity);
+        _arrayFromPool = ArrayPool<T>.Shared.Rent(initialCapacity);
+        _memory = _arrayFromPool;
+    }
+
+    public void Dispose()
+    {
+        var toReturn = _arrayFromPool;
+        if (toReturn is not null)
+        {
+            _arrayFromPool = null;
+            ArrayPool<T>.Shared.Return(toReturn);
+        }
+    }
+
+    public readonly ReadOnlyMemory<T> AsMemory()
+        => _memory[.._index];
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Append(T item)
+    {
+        var index = _index;
+
+        var memory = _memory;
+        if ((uint)index < (uint)memory.Length)
+        {
+            memory.Span[index] = item;
+            _index = index + 1;
+        }
+        else
+        {
+            AppendWithResize(item);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void AppendWithResize(T item)
+    {
+        Debug.Assert(_index == _memory.Length);
+        var index = _index;
+        Grow(1);
+        _memory.Span[index] = item;
+        _index = index + 1;
+    }
+
+    private void Grow(int additionalCapacityRequired = 1)
+    {
+        const int ArrayMaxLength = 0x7FFFFFC7; // same as Array.MaxLength
+
+        var nextCapacity = Math.Max(_memory.Length != 0 ? _memory.Length * 2 : 4, _memory.Length + additionalCapacityRequired);
+
+        if ((uint)nextCapacity > ArrayMaxLength)
+        {
+            nextCapacity = Math.Max(Math.Max(_memory.Length + 1, ArrayMaxLength), _memory.Length);
+        }
+
+        var newArray = ArrayPool<T>.Shared.Rent(nextCapacity);
+        _memory.Span.CopyTo(newArray);
+
+        var toReturn = _arrayFromPool;
+        _memory = newArray;
+        _arrayFromPool = newArray;
+
+        if (toReturn != null)
+        {
+            ArrayPool<T>.Shared.Return(toReturn);
+        }
+    }
+}

From f6bdc0bb50f1662d23b7300d29d9e9f9c336c886 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Wed, 17 Jul 2024 15:50:33 -0700
Subject: [PATCH 05/16] Extract log message formatting and reduce string
 allocations

---
 .../AbstractRazorDocumentMappingService.cs    |   1 +
 .../IRazorDocumentMappingServiceExtensions.cs |   1 +
 .../Extensions/LinePositionSpanExtensions.cs  |   3 +-
 .../Extensions/RangeExtensions.cs             |   1 +
 .../Extensions/RazorSyntaxNodeExtensions.cs   |   1 +
 .../Extensions/TextSpanExtensions.cs          |   1 +
 ...gMessageFormatter.FormattedMessageState.cs | 162 ++++++++++++++++++
 .../Logging/LogMessageFormatter.cs            |  79 +++++++++
 ...osoft.CodeAnalysis.Razor.Workspaces.csproj |   4 -
 .../Debugging/RazorBreakpointSpanResponse.cs  |   1 +
 .../RazorMapToDocumentRangesParams.cs         |   1 +
 .../RazorMapToDocumentRangesResponse.cs       |   1 +
 .../ProvideSemanticTokensRangesParams.cs      |   1 +
 .../Logging/TestOutputLogger.cs               |  80 +--------
 14 files changed, 260 insertions(+), 77 deletions(-)
 create mode 100644 src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.FormattedMessageState.cs
 create mode 100644 src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.cs

diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/AbstractRazorDocumentMappingService.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/AbstractRazorDocumentMappingService.cs
index 759b418d3f6..668ee49d4e9 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/AbstractRazorDocumentMappingService.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/AbstractRazorDocumentMappingService.cs
@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Range = Microsoft.VisualStudio.LanguageServer.Protocol.Range;
 
 namespace Microsoft.CodeAnalysis.Razor.DocumentMapping;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/IRazorDocumentMappingServiceExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/IRazorDocumentMappingServiceExtensions.cs
index cf62802c48d..e5280a6dcc0 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/IRazorDocumentMappingServiceExtensions.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/IRazorDocumentMappingServiceExtensions.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Range = Microsoft.VisualStudio.LanguageServer.Protocol.Range;
 
 namespace Microsoft.CodeAnalysis.Razor.DocumentMapping;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/LinePositionSpanExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/LinePositionSpanExtensions.cs
index 9c59287dad7..ba6e6f19b29 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/LinePositionSpanExtensions.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/LinePositionSpanExtensions.cs
@@ -2,13 +2,14 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
 
 namespace Microsoft.CodeAnalysis.Razor.Workspaces;
 
 internal static class LinePositionSpanExtensions
 {
     public static Range ToRange(this LinePositionSpan linePositionSpan)
-        => new Range
+        => new()
         {
             Start = linePositionSpan.Start.ToPosition(),
             End = linePositionSpan.End.ToPosition()
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RangeExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RangeExtensions.cs
index 09e68a6e7b3..66ac2168234 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RangeExtensions.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RangeExtensions.cs
@@ -4,6 +4,7 @@
 using System;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Range = Microsoft.VisualStudio.LanguageServer.Protocol.Range;
 
 namespace Microsoft.CodeAnalysis.Razor.Workspaces;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs
index b190c4df85d..86fb7ba42df 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs
@@ -13,6 +13,7 @@
 namespace Microsoft.CodeAnalysis.Razor.Workspaces;
 
 using Microsoft.AspNetCore.Razor.Language.Syntax;
+using Range = VisualStudio.LanguageServer.Protocol.Range;
 
 internal static class RazorSyntaxNodeExtensions
 {
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/TextSpanExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/TextSpanExtensions.cs
index d27b8bafcd1..8f5bb6e5d5e 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/TextSpanExtensions.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/TextSpanExtensions.cs
@@ -4,6 +4,7 @@
 using System;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Range = Microsoft.VisualStudio.LanguageServer.Protocol.Range;
 
 namespace Microsoft.CodeAnalysis.Razor.Workspaces;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.FormattedMessageState.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.FormattedMessageState.cs
new file mode 100644
index 00000000000..e9a4d877fa3
--- /dev/null
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.FormattedMessageState.cs
@@ -0,0 +1,162 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.AspNetCore.Razor;
+using static System.StringExtensions;
+
+namespace Microsoft.CodeAnalysis.Razor.Logging;
+
+internal static partial class LogMessageFormatter
+{
+    private readonly struct FormattedMessageState
+    {
+        // The leading whitespace matches the time space length            "[hh:mm:ss.fffffff] "
+        private static readonly ReadOnlyMemory<char> s_leadingWhiteSpace = "                   ".AsMemory();
+
+        private readonly ReadOnlyMemory<char> _message;
+        private readonly ReadOnlyMemory<Range> _messageLineRanges;
+        private readonly ReadOnlyMemory<char> _exceptionText;
+        private readonly ReadOnlyMemory<Range> _exceptionLineRanges;
+        private readonly ReadOnlyMemory<char> _categoryNamePart;
+        private readonly ReadOnlyMemory<char> _timeStampPart;
+        private readonly ReadOnlyMemory<char> _newLine;
+        private readonly ReadOnlyMemory<char> _leadingWhiteSpace;
+
+        public ReadOnlySpan<char> MessageText => _message.Span;
+        public ReadOnlySpan<Range> MessageLineRanges => _messageLineRanges.Span;
+        public ReadOnlySpan<char> ExceptionText => _exceptionText.Span;
+        public ReadOnlySpan<Range> ExceptionLineRanges => _exceptionLineRanges.Span;
+        public ReadOnlySpan<char> CategoryNamePart => _categoryNamePart.Span;
+        public ReadOnlySpan<char> TimeStampPart => _timeStampPart.Span;
+        public ReadOnlySpan<char> NewLine => _newLine.Span;
+        public ReadOnlySpan<char> LeadingWhiteSpace => _leadingWhiteSpace.Span;
+
+        public int Length { get; }
+
+        private FormattedMessageState(
+            ReadOnlyMemory<char> messageText, ReadOnlyMemory<Range> messageLineRanges,
+            ReadOnlyMemory<char> exceptionText, ReadOnlyMemory<Range> exceptionLineRanges,
+            ReadOnlyMemory<char> categoryNamePart,
+            ReadOnlyMemory<char> timeStampPart,
+            ReadOnlyMemory<char> newLine,
+            ReadOnlyMemory<char> leadingWhiteSpace)
+        {
+            _message = messageText;
+            _messageLineRanges = messageLineRanges;
+            _exceptionText = exceptionText;
+            _exceptionLineRanges = exceptionLineRanges;
+            _categoryNamePart = categoryNamePart;
+            _timeStampPart = timeStampPart;
+            _newLine = newLine;
+            _leadingWhiteSpace = leadingWhiteSpace;
+
+            Length = ComputeLength();
+        }
+
+        private int ComputeLength()
+        {
+            // Calculate the length of the final formatted string.
+            var isFirst = true;
+            var length = 0;
+
+            length += CategoryNamePart.Length;
+
+            foreach (var range in MessageLineRanges)
+            {
+                if (isFirst)
+                {
+                    length += TimeStampPart.Length;
+                    isFirst = false;
+                }
+                else
+                {
+                    length += NewLine.Length;
+                    length += LeadingWhiteSpace.Length;
+                }
+
+                var (_, lineLength) = range.GetOffsetAndLength(MessageText.Length);
+                length += lineLength;
+            }
+
+            foreach (var range in ExceptionLineRanges)
+            {
+                length += TimeStampPart.Length;
+
+                var (_, lineLength) = range.GetOffsetAndLength(ExceptionText.Length);
+                length += lineLength;
+            }
+
+            return length;
+        }
+
+        public static FormattedMessageState Create(
+            string message,
+            string categoryName,
+            Exception? exception,
+            bool includeTimeStamp,
+            ref MemoryBuilder<Range> messageLineRangeBuilder,
+            ref MemoryBuilder<Range> exceptionLineRangeBuilder)
+        {
+            var messageText = message.AsMemory();
+            var newLine = Environment.NewLine.AsMemory();
+
+            var categoryNamePart = ('[' + categoryName + "] ").AsMemory();
+
+            ReadOnlyMemory<char> timeStampPart, leadingWhiteSpace;
+
+            if (includeTimeStamp)
+            {
+                timeStampPart = ('[' + DateTime.Now.TimeOfDay.ToString("hh\\:mm\\:ss\\.fffffff") + "] ").AsMemory();
+                leadingWhiteSpace = s_leadingWhiteSpace;
+            }
+            else
+            {
+                timeStampPart = default;
+                leadingWhiteSpace = default;
+            }
+
+            // Collect the range of each line in the message text.
+            CollectLineRanges(messageText.Span, newLine.Span, ref messageLineRangeBuilder);
+
+            var exceptionText = exception is not null
+                ? exception.ToString().AsMemory()
+                : default;
+
+            // If specified, Collect the range of each line in the exception text.
+            if (exceptionText.Length > 0)
+            {
+                CollectLineRanges(exceptionText.Span, newLine.Span, ref exceptionLineRangeBuilder);
+            }
+
+            return new(
+                messageText, messageLineRangeBuilder.AsMemory(),
+                exceptionText, exceptionLineRangeBuilder.AsMemory(),
+                categoryNamePart, timeStampPart, newLine, leadingWhiteSpace);
+        }
+
+        private static void CollectLineRanges(ReadOnlySpan<char> source, ReadOnlySpan<char> newLine, ref MemoryBuilder<Range> builder)
+        {
+            var startIndex = 0;
+
+            while (startIndex < source.Length)
+            {
+                // Find the index of the next new line.
+                var endIndex = source[startIndex..].IndexOf(newLine);
+
+                // If endIndex == -1, there isn't another new line.
+                // So, add the remaining range and break.
+                if (endIndex == -1)
+                {
+                    builder.Append(startIndex..);
+                    break;
+                }
+
+                var realEndIndex = startIndex + endIndex;
+
+                builder.Append(startIndex..realEndIndex);
+                startIndex = realEndIndex + newLine.Length;
+            }
+        }
+    }
+}
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.cs
new file mode 100644
index 00000000000..bfa55365903
--- /dev/null
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.cs
@@ -0,0 +1,79 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using Microsoft.AspNetCore.Razor;
+using static System.StringExtensions;
+
+namespace Microsoft.CodeAnalysis.Razor.Logging;
+
+internal static partial class LogMessageFormatter
+{
+    public static string FormatMessage(string message, string categoryName, Exception? exception, bool includeTimeStamp = true)
+    {
+        // Note
+        MemoryBuilder<Range> messageLineRangeBuilder = new(initialCapacity: 4);
+        MemoryBuilder<Range> exceptionLineRangeBuilder = exception is not null ? new(initialCapacity: 64) : default;
+        try
+        {
+            var state = FormattedMessageState.Create(
+                message, categoryName, exception, includeTimeStamp,
+                ref messageLineRangeBuilder, ref exceptionLineRangeBuilder);
+
+            // Create the final string.
+            return CreateString(state.Length, state, static (span, state) =>
+            {
+                Write(state.CategoryNamePart, ref span);
+
+                var isFirst = true;
+
+                foreach (var range in state.MessageLineRanges)
+                {
+                    if (isFirst)
+                    {
+                        // Write the time stamp if this is the first line.
+                        Write(state.TimeStampPart, ref span);
+                        isFirst = false;
+                    }
+                    else
+                    {
+                        // Otherwise, write a new line and the leading whitespace.
+                        Write(state.NewLine, ref span);
+                        Write(state.LeadingWhiteSpace, ref span);
+                    }
+
+                    Write(state.MessageText[range], ref span);
+                }
+
+                foreach (var range in state.ExceptionLineRanges)
+                {
+                    Write(state.LeadingWhiteSpace, ref span);
+                    Write(state.ExceptionText[range], ref span);
+                }
+
+                Debug.Assert(span.Length == 0, "We didn't fill the whole span!");
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                static void Write(ReadOnlySpan<char> source, ref Span<char> destination)
+                {
+                    if (source.IsEmpty)
+                    {
+                        return;
+                    }
+
+                    source.CopyTo(destination);
+                    destination = destination[source.Length..];
+
+                    Debug.Assert(destination.Length >= 0);
+                }
+            });
+        }
+        finally
+        {
+            messageLineRangeBuilder.Dispose();
+            exceptionLineRangeBuilder.Dispose();
+        }
+    }
+}
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Microsoft.CodeAnalysis.Razor.Workspaces.csproj b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Microsoft.CodeAnalysis.Razor.Workspaces.csproj
index 25f7c700336..e47366a1ae2 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Microsoft.CodeAnalysis.Razor.Workspaces.csproj
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Microsoft.CodeAnalysis.Razor.Workspaces.csproj
@@ -14,10 +14,6 @@
     <NoWarn>$(NoWarn);IDE0073</NoWarn>
   </PropertyGroup>
 
-  <ItemGroup>
-    <Using Alias="Range" Include="Microsoft.VisualStudio.LanguageServer.Protocol.Range" />
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
     <PackageReference Include="Microsoft.CodeAnalysis.ExternalAccess.Razor" />
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/Debugging/RazorBreakpointSpanResponse.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/Debugging/RazorBreakpointSpanResponse.cs
index cfafecfbd05..c12d63eb605 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/Debugging/RazorBreakpointSpanResponse.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/Debugging/RazorBreakpointSpanResponse.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System.Text.Json.Serialization;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
 
 namespace Microsoft.CodeAnalysis.Razor.Protocol.Debugging;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/DocumentMapping/RazorMapToDocumentRangesParams.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/DocumentMapping/RazorMapToDocumentRangesParams.cs
index 6118b3227be..cd9b57edc84 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/DocumentMapping/RazorMapToDocumentRangesParams.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/DocumentMapping/RazorMapToDocumentRangesParams.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Text.Json.Serialization;
 using Microsoft.CodeAnalysis.Razor.DocumentMapping;
+using Range = Microsoft.VisualStudio.LanguageServer.Protocol.Range;
 
 namespace Microsoft.CodeAnalysis.Razor.Protocol.DocumentMapping;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/DocumentMapping/RazorMapToDocumentRangesResponse.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/DocumentMapping/RazorMapToDocumentRangesResponse.cs
index 8692fa83020..60e5f99fbc4 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/DocumentMapping/RazorMapToDocumentRangesResponse.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/DocumentMapping/RazorMapToDocumentRangesResponse.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System.Text.Json.Serialization;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
 
 namespace Microsoft.CodeAnalysis.Razor.Protocol.DocumentMapping;
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/SemanticTokens/ProvideSemanticTokensRangesParams.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/SemanticTokens/ProvideSemanticTokensRangesParams.cs
index 814842e39c5..73e62bf91db 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/SemanticTokens/ProvideSemanticTokensRangesParams.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/SemanticTokens/ProvideSemanticTokensRangesParams.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Text.Json.Serialization;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
+using Range = Microsoft.VisualStudio.LanguageServer.Protocol.Range;
 
 namespace Microsoft.CodeAnalysis.Razor.Workspaces.Protocol.SemanticTokens;
 
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.cs
index 3db5c90b6f4..97a3ce0c3ec 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.cs
@@ -3,33 +3,18 @@
 
 using System;
 using System.Collections.Generic;
-using System.Text;
 using Microsoft.CodeAnalysis.Razor.Logging;
 
 namespace Microsoft.AspNetCore.Razor.Test.Common.Logging;
 
-internal partial class TestOutputLogger : ILogger
+internal partial class TestOutputLogger(TestOutputLoggerProvider provider, string categoryName, LogLevel logLevel = LogLevel.Trace) : ILogger
 {
-    [ThreadStatic]
-    private static StringBuilder? g_builder;
-
-    private readonly TestOutputLoggerProvider _provider;
-
-    public string? CategoryName { get; }
-    public LogLevel LogLevel { get; }
-
-    public TestOutputLogger(
-        TestOutputLoggerProvider provider,
-        string? categoryName = null,
-        LogLevel logLevel = LogLevel.Trace)
-    {
-        _provider = provider ?? throw new ArgumentNullException(nameof(provider));
-        CategoryName = categoryName;
-        LogLevel = logLevel;
-    }
+    private readonly TestOutputLoggerProvider _provider = provider;
+    private readonly string _categoryName = categoryName;
+    private readonly LogLevel _logLevel = logLevel;
 
     public bool IsEnabled(LogLevel logLevel)
-        => logLevel >= LogLevel;
+        => logLevel >= _logLevel;
 
     public void Log(LogLevel logLevel, string message, Exception? exception)
     {
@@ -38,46 +23,11 @@ public void Log(LogLevel logLevel, string message, Exception? exception)
             return;
         }
 
-        var builder = GetEmptyBuilder();
-
-        var time = DateTime.Now.TimeOfDay;
-        var leadingTimeStamp = $"[{time:hh\\:mm\\:ss\\.fffffff}] ";
-        var leadingSpaces = new string(' ', leadingTimeStamp.Length);
-        var lines = message.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
-
-        var isFirstLine = true;
-
-        builder.Append(leadingTimeStamp);
-
-        if (CategoryName is { } categoryName)
-        {
-            builder.Append($"[{categoryName}] ");
-            isFirstLine = lines.Length == 1;
-        }
-
-        foreach (var line in lines)
-        {
-            if (!isFirstLine)
-            {
-                builder.AppendLine();
-                builder.Append(leadingSpaces);
-            }
-
-            builder.Append(line);
-
-            isFirstLine = false;
-        }
-
-        var finalMessage = builder.ToString();
+        var formattedMessage = LogMessageFormatter.FormatMessage(message, _categoryName, exception);
 
         try
         {
-            _provider.TestOutputHelper.WriteLine(finalMessage);
-
-            if (exception is not null)
-            {
-                _provider.TestOutputHelper.WriteLine(exception.ToString());
-            }
+            _provider.TestOutputHelper.WriteLine(formattedMessage);
         }
         catch (Exception ex)
         {
@@ -96,22 +46,8 @@ public void Log(LogLevel logLevel, string message, Exception? exception)
                 innerExceptions.Add(exception);
             }
 
-            var aggregateException = new AggregateException($"An exception occurred while logging: {finalMessage}", innerExceptions);
+            var aggregateException = new AggregateException($"An exception occurred while logging: {formattedMessage}", innerExceptions);
             throw aggregateException.Flatten();
         }
     }
-
-    private static StringBuilder GetEmptyBuilder()
-    {
-        if (g_builder is null)
-        {
-            g_builder = new();
-        }
-        else
-        {
-            g_builder.Clear();
-        }
-
-        return g_builder;
-    }
 }

From 5e636341be43d5f7698a9f0e40bca87b42f27157 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Wed, 17 Jul 2024 15:57:21 -0700
Subject: [PATCH 06/16] Use LogMessageFormatter in a couple existing loggers

---
 .../Logging/MemoryLoggerProvider.Logger.cs                 | 7 ++-----
 .../Logging/OutputWindowLoggerProvider.cs                  | 7 ++-----
 src/Razor/src/rzls/LspLogger.cs                            | 7 ++-----
 3 files changed, 6 insertions(+), 15 deletions(-)

diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.Logger.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.Logger.cs
index 4b65822b9b7..39153edfab4 100644
--- a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.Logger.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.Logger.cs
@@ -18,11 +18,8 @@ public bool IsEnabled(LogLevel logLevel)
 
         public void Log(LogLevel logLevel, string message, Exception? exception)
         {
-            _buffer.Append($"{DateTime.Now:h:mm:ss.fff} [{_categoryName}] {message}");
-            if (exception is not null)
-            {
-                _buffer.Append(exception.ToString());
-            }
+            var formattedMessage = LogMessageFormatter.FormatMessage(message, _categoryName, exception);
+            _buffer.Append(formattedMessage);
         }
     }
 }
diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/OutputWindowLoggerProvider.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/OutputWindowLoggerProvider.cs
index 70a775d6120..310e6b3cf2f 100644
--- a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/OutputWindowLoggerProvider.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/OutputWindowLoggerProvider.cs
@@ -58,11 +58,8 @@ public void Log(LogLevel logLevel, string message, Exception? exception)
         {
             if (IsEnabled(logLevel))
             {
-                _outputPane.WriteLine($"{DateTime.Now:h:mm:ss.fff} [{_categoryName}] {message}");
-                if (exception is not null)
-                {
-                    _outputPane.WriteLine(exception.ToString());
-                }
+                var formattedMessage = LogMessageFormatter.FormatMessage(message, _categoryName, exception);
+                _outputPane.WriteLine(formattedMessage);
             }
         }
     }
diff --git a/src/Razor/src/rzls/LspLogger.cs b/src/Razor/src/rzls/LspLogger.cs
index 384d4a3708b..0f032ed436f 100644
--- a/src/Razor/src/rzls/LspLogger.cs
+++ b/src/Razor/src/rzls/LspLogger.cs
@@ -42,15 +42,12 @@ public void Log(LogLevel logLevel, string message, Exception? exception)
             _ => throw new NotImplementedException(),
         };
 
-        if (exception is not null)
-        {
-            message += Environment.NewLine + exception.ToString();
-        }
+        var formattedMessage = LogMessageFormatter.FormatMessage(message, _categoryName, exception, includeTimeStamp: false);
 
         var @params = new LogMessageParams
         {
             MessageType = messageType,
-            Message = $"[{_categoryName}] {message}",
+            Message = formattedMessage,
         };
 
         _clientConnection.SendNotificationAsync(Methods.WindowLogMessageName, @params, CancellationToken.None).Forget();

From cdae4fa4f4d717cf65a2148f36657ab8a7d9f643 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Wed, 17 Jul 2024 16:27:40 -0700
Subject: [PATCH 07/16] Use same EmptyLoggerFactory throughout Razor

---
 .../RazorDiagnosticsBenchmark.cs              |  7 +--
 .../RazorLanguageServerBenchmarkBase.cs       | 56 +------------------
 .../EmptyLoggingFactory.EmptyLogger.cs        | 25 ---------
 .../Logging/EmptyLoggingFactory.cs            | 22 --------
 .../ProjectSnapshotManagerBenchmarkBase.cs    |  4 +-
 .../Logging/EmptyLoggerFactory.cs             |  3 +-
 .../RazorBrokeredServiceBase.FactoryBase`1.cs |  1 +
 7 files changed, 8 insertions(+), 110 deletions(-)
 delete mode 100644 src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/Logging/EmptyLoggingFactory.EmptyLogger.cs
 delete mode 100644 src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/Logging/EmptyLoggingFactory.cs
 rename src/Razor/src/{Microsoft.CodeAnalysis.Remote.Razor => Microsoft.CodeAnalysis.Razor.Workspaces}/Logging/EmptyLoggerFactory.cs (90%)

diff --git a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorDiagnosticsBenchmark.cs b/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorDiagnosticsBenchmark.cs
index 6ab749d458f..88a1e8dc183 100644
--- a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorDiagnosticsBenchmark.cs
+++ b/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorDiagnosticsBenchmark.cs
@@ -85,7 +85,7 @@ public void Setup()
         RazorRequestContext = new RazorRequestContext(documentContext.Object, null!, "lsp/method", uri: null);
         VersionedDocumentContext = documentContext.Object;
 
-        var loggerFactory = BuildLoggerFactory();
+        var loggerFactory = EmptyLoggerFactory.Instance;
         var languageServerFeatureOptions = BuildFeatureOptions();
         var languageServer = new ClientNotifierService(Diagnostics!);
         var documentMappingService = BuildRazorDocumentMappingService();
@@ -147,11 +147,6 @@ private IRazorDocumentMappingService BuildRazorDocumentMappingService()
         return razorDocumentMappingService.Object;
     }
 
-    private ILoggerFactory BuildLoggerFactory() => Mock.Of<ILoggerFactory>(
-        r => r.GetOrCreateLogger(
-            It.IsAny<string>()) == new NoopLogger(),
-        MockBehavior.Strict);
-
     private string GetFileContents()
         => """
 <div></div>
diff --git a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorLanguageServerBenchmarkBase.cs b/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorLanguageServerBenchmarkBase.cs
index 3759705f138..e999c1f1613 100644
--- a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorLanguageServerBenchmarkBase.cs
+++ b/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/LanguageServer/RazorLanguageServerBenchmarkBase.cs
@@ -28,8 +28,8 @@ public class RazorLanguageServerBenchmarkBase : ProjectSnapshotManagerBenchmarkB
     public RazorLanguageServerBenchmarkBase()
     {
         var (_, serverStream) = FullDuplexStream.CreatePair();
-        Logger = new NoopLogger();
-        var razorLoggerFactory = new NoopLoggerFactory();
+        var razorLoggerFactory = EmptyLoggerFactory.Instance;
+        Logger = razorLoggerFactory.GetOrCreateLogger(GetType());
         RazorLanguageServerHost = RazorLanguageServerHost.Create(
             serverStream,
             serverStream,
@@ -55,7 +55,7 @@ private protected virtual LanguageServerFeatureOptions BuildFeatureOptions()
 
     private protected RazorLanguageServerHost RazorLanguageServerHost { get; }
 
-    private protected NoopLogger Logger { get; }
+    private protected ILogger Logger { get; }
 
     internal async Task<IDocumentSnapshot> GetDocumentSnapshotAsync(string projectFilePath, string filePath, string targetPath)
     {
@@ -106,54 +106,4 @@ public Task<TResponse> SendRequestAsync<TParams, TResponse>(string method, TPara
             throw new NotImplementedException();
         }
     }
-
-    internal class NoopLoggerFactory() : AbstractLoggerFactory([new NoopLoggerProvider()]);
-
-    internal class NoopLoggerProvider : ILoggerProvider
-    {
-        public ILogger CreateLogger(string categoryName)
-        {
-            return new NoopLogger();
-        }
-
-        public void Dispose()
-        {
-        }
-    }
-
-    internal class NoopLogger : ILogger, ILspLogger
-    {
-        public bool IsEnabled(LogLevel logLevel)
-        {
-            return true;
-        }
-
-        public void Log(LogLevel logLevel, string message, Exception exception)
-        {
-        }
-
-        public void LogEndContext(string message, params object[] @params)
-        {
-        }
-
-        public void LogError(string message, params object[] @params)
-        {
-        }
-
-        public void LogException(Exception exception, string message = null, params object[] @params)
-        {
-        }
-
-        public void LogInformation(string message, params object[] @params)
-        {
-        }
-
-        public void LogStartContext(string message, params object[] @params)
-        {
-        }
-
-        public void LogWarning(string message, params object[] @params)
-        {
-        }
-    }
 }
diff --git a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/Logging/EmptyLoggingFactory.EmptyLogger.cs b/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/Logging/EmptyLoggingFactory.EmptyLogger.cs
deleted file mode 100644
index 4ecdf6413e1..00000000000
--- a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/Logging/EmptyLoggingFactory.EmptyLogger.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the MIT license. See License.txt in the project root for license information.
-
-using System;
-using Microsoft.CodeAnalysis.Razor.Logging;
-
-namespace Microsoft.AspNetCore.Razor.Logging;
-
-internal sealed partial class EmptyLoggingFactory
-{
-    private sealed class EmptyLogger : ILogger
-    {
-        public static readonly EmptyLogger Instance = new();
-
-        private EmptyLogger()
-        {
-        }
-
-        public bool IsEnabled(LogLevel logLevel) => false;
-
-        public void Log(LogLevel logLevel, string message, Exception? exception)
-        {
-        }
-    }
-}
diff --git a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/Logging/EmptyLoggingFactory.cs b/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/Logging/EmptyLoggingFactory.cs
deleted file mode 100644
index 13a32a760c3..00000000000
--- a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/Logging/EmptyLoggingFactory.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the MIT license. See License.txt in the project root for license information.
-
-using System;
-using Microsoft.CodeAnalysis.Razor.Logging;
-
-namespace Microsoft.AspNetCore.Razor.Logging;
-
-internal sealed partial class EmptyLoggingFactory : ILoggerFactory
-{
-    public static readonly EmptyLoggingFactory Instance = new();
-
-    private EmptyLoggingFactory()
-    {
-    }
-
-    public void AddLoggerProvider(ILoggerProvider provider)
-        => throw new NotImplementedException();
-
-    public ILogger GetOrCreateLogger(string categoryName)
-        => EmptyLogger.Instance;
-}
diff --git a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/ProjectSystem/ProjectSnapshotManagerBenchmarkBase.cs b/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/ProjectSystem/ProjectSnapshotManagerBenchmarkBase.cs
index 3b2093d90c8..5cee00d2e52 100644
--- a/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/ProjectSystem/ProjectSnapshotManagerBenchmarkBase.cs
+++ b/src/Razor/benchmarks/Microsoft.AspNetCore.Razor.Microbenchmarks/ProjectSystem/ProjectSnapshotManagerBenchmarkBase.cs
@@ -5,9 +5,9 @@
 using System.Collections.Immutable;
 using System.IO;
 using Microsoft.AspNetCore.Razor.Language;
-using Microsoft.AspNetCore.Razor.Logging;
 using Microsoft.AspNetCore.Razor.PooledObjects;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Razor.Logging;
 using Microsoft.CodeAnalysis.Razor.ProjectSystem;
 using Microsoft.CodeAnalysis.Text;
 
@@ -62,6 +62,6 @@ internal ProjectSnapshotManager CreateProjectSnapshotManager()
     {
         return new ProjectSnapshotManager(
             projectEngineFactoryProvider: StaticProjectEngineFactoryProvider.Instance,
-            loggerFactory: EmptyLoggingFactory.Instance);
+            loggerFactory: EmptyLoggerFactory.Instance);
     }
 }
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/Logging/EmptyLoggerFactory.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/EmptyLoggerFactory.cs
similarity index 90%
rename from src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/Logging/EmptyLoggerFactory.cs
rename to src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/EmptyLoggerFactory.cs
index 6ae7e3fcbc7..5490594dd37 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/Logging/EmptyLoggerFactory.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/EmptyLoggerFactory.cs
@@ -2,9 +2,8 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System;
-using Microsoft.CodeAnalysis.Razor.Logging;
 
-namespace Microsoft.CodeAnalysis.Remote.Razor.Logging;
+namespace Microsoft.CodeAnalysis.Razor.Logging;
 
 internal sealed class EmptyLoggerFactory : ILoggerFactory
 {
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/RazorBrokeredServiceBase.FactoryBase`1.cs b/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/RazorBrokeredServiceBase.FactoryBase`1.cs
index f3c1b31d6db..ba5519a1709 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/RazorBrokeredServiceBase.FactoryBase`1.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/RazorBrokeredServiceBase.FactoryBase`1.cs
@@ -6,6 +6,7 @@
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Razor.Logging;
 using Microsoft.CodeAnalysis.Razor.Remote;
 using Microsoft.CodeAnalysis.Remote.Razor.Logging;
 using Microsoft.ServiceHub.Framework;

From c945faf887c8f182e287ab4fadbccafe9a578d41 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Wed, 17 Jul 2024 16:43:14 -0700
Subject: [PATCH 08/16] Use different ILoggerProvider for integration tests and
 clean up

While adding a new ILoggerProvider for integration tests that ignores messages sent after the output is invalid, I noticed a bunch of things to clean up. Importantly, Razor's ILoggerProvider no longer implements IDisposable as the MS.Extensions.Logging version does.
---
 .../Logging/RazorLogHubLoggerProvider.cs      |  4 --
 .../Logging/MemoryLoggerProvider.cs           |  4 --
 .../Logging/OutputWindowLoggerProvider.cs     |  2 +-
 src/Razor/src/rzls/LoggerProvider.cs          |  4 --
 .../TestOutputLogger.NoOpDisposable.cs        | 15 -----
 .../Logging/TestOutputLogger.cs               |  4 +-
 .../Logging/TestOutputLoggerProvider.cs       | 13 +----
 .../AbstractRazorEditorTest.cs                |  6 +-
 .../InProcess/OutputInProcess.cs              | 30 +++-------
 .../Logging/IntegrationTestOutputLogger.cs    | 57 +++++++++++++++++++
 .../IntegrationTestOutputLoggerProvider.cs    | 28 +++++++++
 11 files changed, 101 insertions(+), 66 deletions(-)
 delete mode 100644 src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.NoOpDisposable.cs
 create mode 100644 src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/Logging/IntegrationTestOutputLogger.cs
 create mode 100644 src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/Logging/IntegrationTestOutputLoggerProvider.cs

diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Logging/RazorLogHubLoggerProvider.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Logging/RazorLogHubLoggerProvider.cs
index fee3b5a76ef..b14f41019f0 100644
--- a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Logging/RazorLogHubLoggerProvider.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/LanguageClient/Logging/RazorLogHubLoggerProvider.cs
@@ -17,8 +17,4 @@ public ILogger CreateLogger(string categoryName)
     {
         return new RazorLogHubLogger(categoryName, _traceProvider);
     }
-
-    public void Dispose()
-    {
-    }
 }
diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.cs
index 1d06f244c8b..48286cc0d0b 100644
--- a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/MemoryLoggerProvider.cs
@@ -14,8 +14,4 @@ internal partial class MemoryLoggerProvider : ILoggerProvider
 
     public ILogger CreateLogger(string categoryName)
         => new Logger(_buffer, categoryName);
-
-    public void Dispose()
-    {
-    }
 }
diff --git a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/OutputWindowLoggerProvider.cs b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/OutputWindowLoggerProvider.cs
index 310e6b3cf2f..7b8d939d080 100644
--- a/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/OutputWindowLoggerProvider.cs
+++ b/src/Razor/src/Microsoft.VisualStudio.LanguageServices.Razor/Logging/OutputWindowLoggerProvider.cs
@@ -21,7 +21,7 @@ internal class OutputWindowLoggerProvider(
     // or used anything that does logging, so make sure everything of ours is imported lazily
     Lazy<IClientSettingsManager> clientSettingsManager,
     JoinableTaskContext joinableTaskContext)
-    : ILoggerProvider
+    : ILoggerProvider, IDisposable
 {
     private readonly Lazy<IClientSettingsManager> _clientSettingsManager = clientSettingsManager;
     private readonly OutputPane _outputPane = new OutputPane(joinableTaskContext);
diff --git a/src/Razor/src/rzls/LoggerProvider.cs b/src/Razor/src/rzls/LoggerProvider.cs
index 768c713a454..3aa536e5618 100644
--- a/src/Razor/src/rzls/LoggerProvider.cs
+++ b/src/Razor/src/rzls/LoggerProvider.cs
@@ -15,8 +15,4 @@ public ILogger CreateLogger(string categoryName)
     {
         return new LspLogger(categoryName, _logLevel, _clientConnection);
     }
-
-    public void Dispose()
-    {
-    }
 }
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.NoOpDisposable.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.NoOpDisposable.cs
deleted file mode 100644
index 7da2abfdaa4..00000000000
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.NoOpDisposable.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the MIT license. See License.txt in the project root for license information.
-
-using System;
-
-namespace Microsoft.AspNetCore.Razor.Test.Common.Logging;
-
-internal sealed class NoOpDisposable : IDisposable
-{
-    public static IDisposable Instance { get; } = new NoOpDisposable();
-
-    public void Dispose()
-    {
-    }
-}
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.cs
index 97a3ce0c3ec..f983d081e25 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLogger.cs
@@ -18,7 +18,7 @@ public bool IsEnabled(LogLevel logLevel)
 
     public void Log(LogLevel logLevel, string message, Exception? exception)
     {
-        if (!IsEnabled(logLevel) || _provider.TestOutputHelper is null)
+        if (!IsEnabled(logLevel))
         {
             return;
         }
@@ -27,7 +27,7 @@ public void Log(LogLevel logLevel, string message, Exception? exception)
 
         try
         {
-            _provider.TestOutputHelper.WriteLine(formattedMessage);
+            _provider.Output.WriteLine(formattedMessage);
         }
         catch (Exception ex)
         {
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLoggerProvider.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLoggerProvider.cs
index f0f12639193..2e6619828b7 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLoggerProvider.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/Logging/TestOutputLoggerProvider.cs
@@ -8,20 +8,11 @@ namespace Microsoft.AspNetCore.Razor.Test.Common.Logging;
 
 internal class TestOutputLoggerProvider(ITestOutputHelper output, LogLevel logLevel = LogLevel.Trace) : ILoggerProvider
 {
-    private ITestOutputHelper? _output = output;
+    private readonly ITestOutputHelper _output = output;
     private readonly LogLevel _logLevel = logLevel;
 
-    public ITestOutputHelper? TestOutputHelper => _output;
+    public ITestOutputHelper Output => _output;
 
     public ILogger CreateLogger(string categoryName)
         => new TestOutputLogger(this, categoryName, _logLevel);
-
-    public void Dispose()
-    {
-    }
-
-    internal void SetTestOutputHelper(ITestOutputHelper? testOutputHelper)
-    {
-        _output = testOutputHelper;
-    }
 }
diff --git a/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/AbstractRazorEditorTest.cs b/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/AbstractRazorEditorTest.cs
index 1ae085f93af..440fe6f0df0 100644
--- a/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/AbstractRazorEditorTest.cs
+++ b/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/AbstractRazorEditorTest.cs
@@ -20,9 +20,9 @@
 namespace Microsoft.VisualStudio.Razor.IntegrationTests;
 
 [LogIntegrationTest]
-public abstract class AbstractRazorEditorTest(ITestOutputHelper testOutputHelper) : AbstractIntegrationTest
+public abstract class AbstractRazorEditorTest(ITestOutputHelper testOutput) : AbstractIntegrationTest
 {
-    private readonly ITestOutputHelper _testOutputHelper = testOutputHelper;
+    private readonly ITestOutputHelper _testOutput = testOutput;
     private ILogger? _testLogger;
     private string? _projectFilePath;
 
@@ -38,7 +38,7 @@ public override async Task InitializeAsync()
     {
         await base.InitializeAsync();
 
-        _testLogger = await TestServices.Output.SetupIntegrationTestLoggerAsync(_testOutputHelper, ControlledHangMitigatingCancellationToken);
+        _testLogger = await TestServices.Output.SetupIntegrationTestLoggerAsync(_testOutput, ControlledHangMitigatingCancellationToken);
 
         _testLogger.LogInformation($"#### Razor integration test initialize.");
 
diff --git a/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/InProcess/OutputInProcess.cs b/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/InProcess/OutputInProcess.cs
index a76d1837354..358e850579e 100644
--- a/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/InProcess/OutputInProcess.cs
+++ b/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/InProcess/OutputInProcess.cs
@@ -4,9 +4,9 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.AspNetCore.Razor.Test.Common.Logging;
 using Microsoft.CodeAnalysis.Razor.Logging;
 using Microsoft.VisualStudio.Razor.IntegrationTests.Extensions;
+using Microsoft.VisualStudio.Razor.IntegrationTests.Logging;
 using Microsoft.VisualStudio.Razor.Settings;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
@@ -20,7 +20,7 @@ internal partial class OutputInProcess
 {
     private const string RazorPaneName = "Razor Logger Output";
 
-    private TestOutputLoggerProvider? _testLoggerProvider;
+    private IntegrationTestOutputLoggerProvider? _testLoggerProvider;
 
     public async Task<ILogger> SetupIntegrationTestLoggerAsync(ITestOutputHelper testOutputHelper, CancellationToken cancellationToken)
     {
@@ -28,25 +28,25 @@ public async Task<ILogger> SetupIntegrationTestLoggerAsync(ITestOutputHelper tes
         var clientSettingsManager = await TestServices.Shell.GetComponentModelServiceAsync<IClientSettingsManager>(cancellationToken);
         clientSettingsManager.Update(clientSettingsManager.GetClientSettings().AdvancedSettings with { LogLevel = LogLevel.Trace });
 
-        var logger = await TestServices.Shell.GetComponentModelServiceAsync<ILoggerFactory>(cancellationToken);
+        var loggerFactory = await TestServices.Shell.GetComponentModelServiceAsync<ILoggerFactory>(cancellationToken);
 
         // We can't remove logging providers, so we just keep track of ours so we can make sure it points to the right test output helper
         if (_testLoggerProvider is null)
         {
-            _testLoggerProvider = new TestOutputLoggerProvider(testOutputHelper);
-            logger.AddLoggerProvider(_testLoggerProvider);
+            _testLoggerProvider = new IntegrationTestOutputLoggerProvider(testOutputHelper);
+            loggerFactory.AddLoggerProvider(_testLoggerProvider);
         }
         else
         {
-            _testLoggerProvider.SetTestOutputHelper(testOutputHelper);
+            _testLoggerProvider.SetOutput(testOutputHelper);
         }
 
-        return logger.GetOrCreateLogger(GetType().Name);
+        return loggerFactory.GetOrCreateLogger(GetType().Name);
     }
 
     public void ClearIntegrationTestLogger()
     {
-        _testLoggerProvider?.SetTestOutputHelper(null);
+        _testLoggerProvider?.SetOutput(null);
     }
 
     public async Task<bool> HasErrorsAsync(CancellationToken cancellationToken)
@@ -110,18 +110,4 @@ static IVsTextView OutputWindowPaneToIVsTextView(EnvDTE.OutputWindowPane outputW
             return textView;
         }
     }
-
-    private class NullLogger : ILogger
-    {
-        public static ILogger Instance { get; } = new NullLogger();
-
-        public bool IsEnabled(LogLevel logLevel)
-        {
-            return false;
-        }
-
-        public void Log(LogLevel logLevel, string message, Exception? exception)
-        {
-        }
-    }
 }
diff --git a/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/Logging/IntegrationTestOutputLogger.cs b/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/Logging/IntegrationTestOutputLogger.cs
new file mode 100644
index 00000000000..bb02202b8c9
--- /dev/null
+++ b/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/Logging/IntegrationTestOutputLogger.cs
@@ -0,0 +1,57 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.Razor.Logging;
+
+namespace Microsoft.VisualStudio.Razor.IntegrationTests.Logging;
+
+internal partial class IntegrationTestOutputLogger(IntegrationTestOutputLoggerProvider provider, string categoryName, LogLevel logLevel = LogLevel.Trace) : ILogger
+{
+    private readonly IntegrationTestOutputLoggerProvider _provider = provider;
+    private readonly string _categoryName = categoryName;
+    private readonly LogLevel _logLevel = logLevel;
+
+    public bool IsEnabled(LogLevel logLevel)
+        => logLevel >= _logLevel;
+
+    public void Log(LogLevel logLevel, string message, Exception? exception)
+    {
+        if (!IsEnabled(logLevel) || !_provider.HasOutput)
+        {
+            return;
+        }
+
+        var formattedMessage = LogMessageFormatter.FormatMessage(message, _categoryName, exception);
+
+        try
+        {
+            _provider.WriteLine(formattedMessage);
+        }
+        catch (InvalidOperationException ex) when (ex.Message == "There is no currently active test.")
+        {
+            // Ignore, something is logging a message outside of a test. Other loggers will capture it.
+        }
+        catch (Exception ex)
+        {
+            // If an exception is thrown while writing a message, throw an AggregateException that includes
+            // the message that was being logged, along with the exception that was thrown and any exception
+            // that was being logged. This might provide clues to the cause.
+
+            var innerExceptions = new List<Exception>
+            {
+                ex
+            };
+
+            // Were we logging an exception? If so, add that too.
+            if (exception is not null)
+            {
+                innerExceptions.Add(exception);
+            }
+
+            var aggregateException = new AggregateException($"An exception occurred while logging: {formattedMessage}", innerExceptions);
+            throw aggregateException.Flatten();
+        }
+    }
+}
diff --git a/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/Logging/IntegrationTestOutputLoggerProvider.cs b/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/Logging/IntegrationTestOutputLoggerProvider.cs
new file mode 100644
index 00000000000..2d390b701c7
--- /dev/null
+++ b/src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/Logging/IntegrationTestOutputLoggerProvider.cs
@@ -0,0 +1,28 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using Microsoft.CodeAnalysis.Razor.Logging;
+using Xunit.Abstractions;
+
+namespace Microsoft.VisualStudio.Razor.IntegrationTests.Logging;
+
+internal class IntegrationTestOutputLoggerProvider(ITestOutputHelper output, LogLevel logLevel = LogLevel.Trace) : ILoggerProvider
+{
+    private ITestOutputHelper? _output = output;
+    private readonly LogLevel _logLevel = logLevel;
+
+    public bool HasOutput => _output is not null;
+
+    public ILogger CreateLogger(string categoryName)
+        => new IntegrationTestOutputLogger(this, categoryName, _logLevel);
+
+    public void SetOutput(ITestOutputHelper? output)
+    {
+        _output = output;
+    }
+
+    public void WriteLine(string message)
+    {
+        _output?.WriteLine(message);
+    }
+}

From 54f3d279b4da127f935e8d0308251b35625f8297 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Thu, 18 Jul 2024 08:58:10 -0700
Subject: [PATCH 09/16] Apply code review feedback for MemoryBuilder<T>

---
 .../MemoryBuilderTests.cs                     | 105 ++++++++++++++++++
 .../MemoryBuilder`1.cs                        |  76 ++++++++++---
 2 files changed, 167 insertions(+), 14 deletions(-)
 create mode 100644 src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared.Test/MemoryBuilderTests.cs

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared.Test/MemoryBuilderTests.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared.Test/MemoryBuilderTests.cs
new file mode 100644
index 00000000000..2792c7c7940
--- /dev/null
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared.Test/MemoryBuilderTests.cs
@@ -0,0 +1,105 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using Xunit;
+
+namespace Microsoft.AspNetCore.Razor.Utilities.Shared.Test;
+
+public class MemoryBuilderTests
+{
+    [Fact]
+    public void StartWithDefault()
+    {
+        using MemoryBuilder<int> builder = default;
+
+        for (var i = 0; i < 1000; i++)
+        {
+            builder.Append(i);
+        }
+
+        var result = builder.AsMemory();
+
+        for (var i = 0; i < 1000; i++)
+        {
+            Assert.Equal(i, result.Span[i]);
+        }
+    }
+
+    [Fact]
+    public void StartWithNew()
+    {
+        using MemoryBuilder<int> builder = new();
+
+        for (var i = 0; i < 1000; i++)
+        {
+            builder.Append(i);
+        }
+
+        var result = builder.AsMemory();
+
+        for (var i = 0; i < 1000; i++)
+        {
+            Assert.Equal(i, result.Span[i]);
+        }
+    }
+
+    [Fact]
+    public void StartWithInitialCapacity()
+    {
+        using MemoryBuilder<int> builder = new(1024);
+
+        for (var i = 0; i < 1000; i++)
+        {
+            builder.Append(i);
+        }
+
+        var result = builder.AsMemory();
+
+        for (var i = 0; i < 1000; i++)
+        {
+            Assert.Equal(i, result.Span[i]);
+        }
+    }
+
+    [Fact]
+    public void StartWithInitialArray()
+    {
+        using MemoryBuilder<int> builder = new(1024);
+
+        for (var i = 0; i < 1000; i++)
+        {
+            builder.Append(i);
+        }
+
+        var result = builder.AsMemory();
+
+        for (var i = 0; i < 1000; i++)
+        {
+            Assert.Equal(i, result.Span[i]);
+        }
+    }
+
+    [Fact]
+    public void AppendChunks()
+    {
+        using MemoryBuilder<int> builder = default;
+
+        ReadOnlySpan<int> chunk = [1, 2, 3, 4, 5, 6, 7, 8];
+
+        for (var i = 0; i < 1000; i++)
+        {
+            builder.Append(chunk);
+        }
+
+        var result = builder.AsMemory();
+
+        for (var i = 0; i < 1000; i++)
+        {
+            for (var j = 0; j < chunk.Length; j++)
+            {
+                Assert.Equal(chunk[j], result.Span[(i * 8) + j]);
+            }
+        }
+    }
+}
diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
index de2497e5c1e..ba7c67447fc 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
@@ -6,6 +6,8 @@
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
+// Inspired by https://github.com/dotnet/runtime/blob/9c7ee976fd771c183e98cf629e3776bba4e45ccc/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/ValueListBuilder.cs
+
 namespace Microsoft.AspNetCore.Razor;
 
 /// <summary>
@@ -15,13 +17,17 @@ internal ref struct MemoryBuilder<T>
 {
     private Memory<T> _memory;
     private T[]? _arrayFromPool;
-    private int _index;
+    private int _length;
 
-    public MemoryBuilder(int initialCapacity = 1)
+    public MemoryBuilder(int initialCapacity = 0)
     {
-        ArgHelper.ThrowIfNegativeOrZero(initialCapacity);
-        _arrayFromPool = ArrayPool<T>.Shared.Rent(initialCapacity);
-        _memory = _arrayFromPool;
+        ArgHelper.ThrowIfNegative(initialCapacity);
+
+        if (initialCapacity > 0)
+        {
+            _arrayFromPool = ArrayPool<T>.Shared.Rent(initialCapacity);
+            _memory = _arrayFromPool;
+        }
     }
 
     public void Dispose()
@@ -29,24 +35,25 @@ public void Dispose()
         var toReturn = _arrayFromPool;
         if (toReturn is not null)
         {
+            _memory = default;
             _arrayFromPool = null;
             ArrayPool<T>.Shared.Return(toReturn);
         }
     }
 
     public readonly ReadOnlyMemory<T> AsMemory()
-        => _memory[.._index];
+        => _memory[.._length];
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Append(T item)
     {
-        var index = _index;
-
+        var index = _length;
         var memory = _memory;
+
         if ((uint)index < (uint)memory.Length)
         {
             memory.Span[index] = item;
-            _index = index + 1;
+            _length = index + 1;
         }
         else
         {
@@ -54,25 +61,66 @@ public void Append(T item)
         }
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Append(ReadOnlySpan<T> source)
+    {
+        var index = _length;
+        var memory = _memory;
+
+        if (source.Length == 1 && (uint)index < (uint)memory.Length)
+        {
+            memory.Span[index] = source[0];
+            _length = index + 1;
+        }
+        else
+        {
+            AppendWithResize(source);
+        }
+    }
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     private void AppendWithResize(T item)
     {
-        Debug.Assert(_index == _memory.Length);
-        var index = _index;
+        Debug.Assert(_length == _memory.Length);
+        var index = _length;
         Grow(1);
         _memory.Span[index] = item;
-        _index = index + 1;
+        _length = index + 1;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private void AppendWithResize(ReadOnlySpan<T> source)
+    {
+        if ((uint)(_length + source.Length) > (uint)_memory.Length)
+        {
+            Grow(_memory.Length - _length + source.Length);
+        }
+
+        source.CopyTo(_memory.Span[_length..]);
+        _length += source.Length;
     }
 
     private void Grow(int additionalCapacityRequired = 1)
     {
+        Debug.Assert(additionalCapacityRequired > 0);
+
         const int ArrayMaxLength = 0x7FFFFFC7; // same as Array.MaxLength
 
-        var nextCapacity = Math.Max(_memory.Length != 0 ? _memory.Length * 2 : 4, _memory.Length + additionalCapacityRequired);
+        // Double the size of the array. If it's currently empty, default to size 4.
+        var nextCapacity = Math.Max(
+            _memory.Length != 0 ? _memory.Length * 2 : 4,
+            _memory.Length + additionalCapacityRequired);
 
+        // If nextCapacity exceeds the possible length of an array, then we want to downgrade to
+        // either ArrayMaxLength, if that's large enough to hold an additional item, or
+        // _memory.Length + 1, if that's larger than ArrayMaxLength. Essentially, we don't want
+        // to simply clamp to ArrayMaxLength if that isn't actually large enough. Instead, if
+        // we've grown too large, we want to OOM when Rent is called below.
         if ((uint)nextCapacity > ArrayMaxLength)
         {
-            nextCapacity = Math.Max(Math.Max(_memory.Length + 1, ArrayMaxLength), _memory.Length);
+            nextCapacity = Math.Max(
+                Math.Max(_memory.Length + 1, ArrayMaxLength),
+                _memory.Length);
         }
 
         var newArray = ArrayPool<T>.Shared.Rent(nextCapacity);

From 590205be167d0776f6d8e25a62e4a237741654f3 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Thu, 18 Jul 2024 08:59:25 -0700
Subject: [PATCH 10/16] Add comment back to CodeWriter.GenerateString(...)

---
 .../src/Language/CodeGeneration/CodeWriter.cs                  | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
index 96bfcaa31ea..d2e2260ad5e 100644
--- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
+++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/CodeGeneration/CodeWriter.cs
@@ -310,6 +310,9 @@ public CodeWriter WriteLine([InterpolatedStringHandlerArgument("")] ref WriteInt
 
     public string GenerateCode()
     {
+        // Eventually, we need to remove this and not return a giant string, which can
+        // easily be allocated on the LOH. The work to remove this is tracked by
+        // https://github.com/dotnet/razor/issues/8076.
         return CreateString(Length, _pages, static (span, pages) =>
         {
             foreach (var page in pages)

From 4002d45a8d57134801ecba60b72ec112df5ba58b Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Thu, 18 Jul 2024 09:00:27 -0700
Subject: [PATCH 11/16] Use static lambda

---
 .../StringExtensions.cs                                         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
index 5741c8ea5d8..3c766ce6a07 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
@@ -561,7 +561,7 @@ public static bool EndsWith(this string text, char value)
     public unsafe static string CreateString<TState>(int length, TState state, SpanAction<char, TState> action)
     {
 #if NET
-        return string.Create(length, (action, state), (span, state) => state.action(span, state.state));
+        return string.Create(length, (action, state), static (span, state) => state.action(span, state.state));
 #else
         ArgHelper.ThrowIfNegative(length);
 

From 6fa6e780c0df76c926dc00552baf65219a7aa853 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Thu, 18 Jul 2024 09:05:00 -0700
Subject: [PATCH 12/16] Assert that nextCapacity > _memory.Length in
 MemoryBuilder<T>

---
 .../MemoryBuilder`1.cs                                          | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
index ba7c67447fc..a40d40ea5b0 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
@@ -123,6 +123,8 @@ private void Grow(int additionalCapacityRequired = 1)
                 _memory.Length);
         }
 
+        Debug.Assert(nextCapacity > _memory.Length);
+
         var newArray = ArrayPool<T>.Shared.Rent(nextCapacity);
         _memory.Span.CopyTo(newArray);
 

From bdb13486081cf094ab7d93eecc3b9d46917a6254 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Thu, 18 Jul 2024 09:11:27 -0700
Subject: [PATCH 13/16] Use static readonly field

---
 .../Logging/LogMessageFormatter.FormattedMessageState.cs       | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.FormattedMessageState.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.FormattedMessageState.cs
index e9a4d877fa3..82876a47576 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.FormattedMessageState.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Logging/LogMessageFormatter.FormattedMessageState.cs
@@ -13,6 +13,7 @@ private readonly struct FormattedMessageState
     {
         // The leading whitespace matches the time space length            "[hh:mm:ss.fffffff] "
         private static readonly ReadOnlyMemory<char> s_leadingWhiteSpace = "                   ".AsMemory();
+        private static readonly ReadOnlyMemory<char> s_newLine = Environment.NewLine.AsMemory();
 
         private readonly ReadOnlyMemory<char> _message;
         private readonly ReadOnlyMemory<Range> _messageLineRanges;
@@ -99,7 +100,7 @@ public static FormattedMessageState Create(
             ref MemoryBuilder<Range> exceptionLineRangeBuilder)
         {
             var messageText = message.AsMemory();
-            var newLine = Environment.NewLine.AsMemory();
+            var newLine = s_newLine;
 
             var categoryNamePart = ('[' + categoryName + "] ").AsMemory();
 

From 3b480de90329c4e9161943ddf831782b24dd1f27 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Thu, 18 Jul 2024 09:39:58 -0700
Subject: [PATCH 14/16] Use ThrowHelper within ArgHelper

---
 .../ArgHelper.cs                              | 112 +--------
 .../ArrayExtensions.cs                        |  13 +-
 .../PooledObjects/PooledArrayBuilder`1.cs     |   3 +-
 .../ReadOnlyListExtensions.cs                 |  38 +--
 .../StringExtensions.cs                       |  11 +-
 .../ThrowHelper.cs                            | 235 ++++++++++++++++++
 .../Utilities/ThrowHelper.cs                  |  45 ----
 7 files changed, 279 insertions(+), 178 deletions(-)
 create mode 100644 src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ThrowHelper.cs
 delete mode 100644 src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/Utilities/ThrowHelper.cs

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ArgHelper.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ArgHelper.cs
index b7857cd0e41..3e7b9982f1d 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ArgHelper.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ArgHelper.cs
@@ -19,7 +19,7 @@ public static void ThrowIfNull([NotNull] object? argument, [CallerArgumentExpres
 #else
         if (argument is null)
         {
-            ThrowArgumentNullException(paramName);
+            ThrowHelper.ThrowArgumentNullException(paramName);
         }
 #endif
     }
@@ -31,36 +31,20 @@ public static unsafe void ThrowIfNull([NotNull] void* argument, [CallerArgumentE
 #else
         if (argument is null)
         {
-            ThrowArgumentNullException(paramName);
+            ThrowHelper.ThrowArgumentNullException(paramName);
         }
 #endif
     }
 
-#if !NET8_0_OR_GREATER
-    [DoesNotReturn]
-    [MethodImpl(MethodImplOptions.NoInlining)]
-    private static void ThrowArgumentNullException(string? paramName)
-    {
-        throw new ArgumentNullException(paramName);
-    }
-#endif
-
     public static void ThrowIfNullOrEmpty([NotNull] string? argument, [CallerArgumentExpression(nameof(argument))] string? paramName = null)
     {
 #if NET8_0_OR_GREATER
         ArgumentException.ThrowIfNullOrEmpty(argument, paramName);
 #else
         if (argument.IsNullOrEmpty())
-        {
-            ThrowException(argument, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(string? argument, string? paramName)
         {
             ThrowIfNull(argument, paramName);
-            throw new ArgumentException(SR.The_value_cannot_be_an_empty_string, paramName);
+            ThrowHelper.ThrowArgumentException(paramName, SR.The_value_cannot_be_an_empty_string);
         }
 #endif
     }
@@ -72,16 +56,9 @@ public static void ThrowIfNullOrWhiteSpace([NotNull] string? argument, [CallerAr
 #else
 
         if (argument.IsNullOrWhiteSpace())
-        {
-            ThrowException(argument, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(string? argument, string? paramName)
         {
             ThrowIfNull(argument, paramName);
-            throw new ArgumentException(SR.The_value_cannot_be_an_empty_string_composed_entirely_of_whitespace, paramName);
+            ThrowHelper.ThrowArgumentException(paramName, SR.The_value_cannot_be_an_empty_string_composed_entirely_of_whitespace);
         }
 #endif
     }
@@ -93,14 +70,7 @@ public static void ThrowIfZero(int value, [CallerArgumentExpression(nameof(value
 #else
         if (value == 0)
         {
-            ThrowException(value, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(int value, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_a_non_zero_value(paramName, value));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_a_non_zero_value(paramName, value));
         }
 #endif
     }
@@ -112,14 +82,7 @@ public static void ThrowIfNegative(int value, [CallerArgumentExpression(nameof(v
 #else
         if (value < 0)
         {
-            ThrowException(value, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(int value, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_a_non_negative_value(paramName, value));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_a_non_negative_value(paramName, value));
         }
 #endif
     }
@@ -131,14 +94,7 @@ public static void ThrowIfNegativeOrZero(int value, [CallerArgumentExpression(na
 #else
         if (value <= 0)
         {
-            ThrowException(value, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(int value, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_a_non_negative_and_non_zero_value(paramName, value));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_a_non_negative_and_non_zero_value(paramName, value));
         }
 #endif
     }
@@ -151,14 +107,7 @@ public static void ThrowIfEqual<T>(T value, T other, [CallerArgumentExpression(n
 #else
         if (EqualityComparer<T>.Default.Equals(value, other))
         {
-            ThrowException(value, other, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(T value, T other, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_not_be_equal_to_2(paramName, (object?)value ?? "null", (object?)other ?? "null"));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_not_be_equal_to_2(paramName, (object?)value ?? "null", (object?)other ?? "null"));
         }
 #endif
     }
@@ -171,14 +120,7 @@ public static void ThrowIfNotEqual<T>(T value, T other, [CallerArgumentExpressio
 #else
         if (!EqualityComparer<T>.Default.Equals(value, other))
         {
-            ThrowException(value, other, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(T value, T other, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_equal_to_2(paramName, (object?)value ?? "null", (object?)other ?? "null"));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_equal_to_2(paramName, (object?)value ?? "null", (object?)other ?? "null"));
         }
 #endif
     }
@@ -191,14 +133,7 @@ public static void ThrowIfGreaterThan<T>(T value, T other, [CallerArgumentExpres
 #else
         if (value.CompareTo(other) > 0)
         {
-            ThrowException(value, other, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(T value, T other, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_less_than_or_equal_to_2(paramName, value, other));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_less_than_or_equal_to_2(paramName, value, other));
         }
 #endif
     }
@@ -211,14 +146,7 @@ public static void ThrowIfGreaterThanOrEqual<T>(T value, T other, [CallerArgumen
 #else
         if (value.CompareTo(other) >= 0)
         {
-            ThrowException(value, other, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(T value, T other, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_less_than_2(paramName, value, other));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_less_than_2(paramName, value, other));
         }
 #endif
     }
@@ -231,14 +159,7 @@ public static void ThrowIfLessThan<T>(T value, T other, [CallerArgumentExpressio
 #else
         if (value.CompareTo(other) < 0)
         {
-            ThrowException(value, other, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(T value, T other, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_greater_than_or_equal_to_2(paramName, value, other));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_greater_than_or_equal_to_2(paramName, value, other));
         }
 #endif
     }
@@ -251,14 +172,7 @@ public static void ThrowIfLessThanOrEqual<T>(T value, T other, [CallerArgumentEx
 #else
         if (value.CompareTo(other) <= 0)
         {
-            ThrowException(value, other, paramName);
-        }
-
-        [DoesNotReturn]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        static void ThrowException(T value, T other, string? paramName)
-        {
-            throw new ArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_greater_than_2(paramName, value, other));
+            ThrowHelper.ThrowArgumentOutOfRangeException(paramName, value, SR.Format0_1_must_be_greater_than_2(paramName, value, other));
         }
 #endif
     }
diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ArrayExtensions.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ArrayExtensions.cs
index f09b4c8176e..526e6d161fa 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ArrayExtensions.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ArrayExtensions.cs
@@ -4,10 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-
-#if !NET
-using ThrowHelper = Microsoft.AspNetCore.Razor.Utilities.ThrowHelper;
-#endif
+using Microsoft.AspNetCore.Razor;
 
 namespace Microsoft.AspNetCore.Razor;
 
@@ -43,7 +40,7 @@ public static ReadOnlySpan<T> AsSpan<T>(this T[]? array, Index startIndex)
         {
             if (!startIndex.Equals(Index.Start))
             {
-                ThrowHelper.ThrowArgumentOutOfRange(nameof(startIndex));
+                ThrowHelper.ThrowArgumentOutOfRangeException(nameof(startIndex));
             }
 
             return default;
@@ -86,7 +83,7 @@ public static ReadOnlySpan<T> AsSpan<T>(this T[]? array, Range range)
         {
             if (!range.Start.Equals(Index.Start) || !range.End.Equals(Index.Start))
             {
-                ThrowHelper.ThrowArgumentNull(nameof(array));
+                ThrowHelper.ThrowArgumentNullException(nameof(array));
             }
 
             return default;
@@ -128,7 +125,7 @@ public static ReadOnlyMemory<T> AsMemory<T>(this T[]? array, Index startIndex)
         {
             if (!startIndex.Equals(Index.Start))
             {
-                ThrowHelper.ThrowArgumentOutOfRange(nameof(startIndex));
+                ThrowHelper.ThrowArgumentOutOfRangeException(nameof(startIndex));
             }
 
             return default;
@@ -172,7 +169,7 @@ public static ReadOnlyMemory<T> AsMemory<T>(this T[]? array, Range range)
         {
             if (!range.Start.Equals(Index.Start) || !range.End.Equals(Index.Start))
             {
-                ThrowHelper.ThrowArgumentNull(nameof(array));
+                ThrowHelper.ThrowArgumentNullException(nameof(array));
             }
 
             return default;
diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/PooledObjects/PooledArrayBuilder`1.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/PooledObjects/PooledArrayBuilder`1.cs
index 57a94f9863d..457b72c0988 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/PooledObjects/PooledArrayBuilder`1.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/PooledObjects/PooledArrayBuilder`1.cs
@@ -7,6 +7,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
+using Microsoft.AspNetCore.Razor;
 using Microsoft.AspNetCore.Razor.Utilities;
 
 namespace Microsoft.AspNetCore.Razor.PooledObjects;
@@ -1306,7 +1307,7 @@ private static void ThrowIndexOutOfRangeException()
     /// </summary>
     [DoesNotReturn]
     private static T ThrowInvalidOperation(string message)
-        => ThrowHelper.ThrowInvalidOperation<T>(message);
+        => ThrowHelper.ThrowInvalidOperationException<T>(message);
 
     [MemberNotNull(nameof(_builder))]
     private void MoveInlineItemsToBuilder()
diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ReadOnlyListExtensions.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ReadOnlyListExtensions.cs
index 61855e0ec91..a62950ce924 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ReadOnlyListExtensions.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ReadOnlyListExtensions.cs
@@ -2,8 +2,8 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System.Collections.Immutable;
+using Microsoft.AspNetCore.Razor;
 using Microsoft.AspNetCore.Razor.PooledObjects;
-using Microsoft.AspNetCore.Razor.Utilities;
 
 namespace System.Collections.Generic;
 
@@ -169,7 +169,7 @@ public static bool All<T, TArg>(this IReadOnlyList<T> list, TArg arg, Func<T, TA
     ///  The list is empty.
     /// </exception>
     public static T First<T>(this IReadOnlyList<T> list)
-        => list.Count > 0 ? list[0] : ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_elements);
+        => list.Count > 0 ? list[0] : ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_elements);
 
     /// <summary>
     ///  Returns the first element in a list that satisfies a specified condition.
@@ -196,7 +196,7 @@ public static T First<T>(this IReadOnlyList<T> list, Func<T, bool> predicate)
             }
         }
 
-        return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_matching_elements);
+        return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_matching_elements);
     }
 
     /// <summary>
@@ -227,7 +227,7 @@ public static T First<T, TArg>(this IReadOnlyList<T> list, TArg arg, Func<T, TAr
             }
         }
 
-        return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_matching_elements);
+        return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_matching_elements);
     }
 
     /// <summary>
@@ -329,7 +329,7 @@ public static T FirstOrDefault<T>(this IReadOnlyList<T> list, T defaultValue)
     ///  The list is empty.
     /// </exception>
     public static T Last<T>(this IReadOnlyList<T> list)
-        => list.Count > 0 ? list[^1] : ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_elements);
+        => list.Count > 0 ? list[^1] : ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_elements);
 
     /// <summary>
     ///  Returns the last element of a list that satisfies a specified condition.
@@ -356,7 +356,7 @@ public static T Last<T>(this IReadOnlyList<T> list, Func<T, bool> predicate)
             }
         }
 
-        return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_matching_elements);
+        return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_matching_elements);
     }
 
     /// <summary>
@@ -387,7 +387,7 @@ public static T Last<T, TArg>(this IReadOnlyList<T> list, TArg arg, Func<T, TArg
             }
         }
 
-        return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_matching_elements);
+        return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_matching_elements);
     }
 
     /// <summary>
@@ -559,8 +559,8 @@ public static T Single<T>(this IReadOnlyList<T> list)
         return list.Count switch
         {
             1 => list[0],
-            0 => ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_elements),
-            _ => ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_element)
+            0 => ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_elements),
+            _ => ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_element)
         };
     }
 
@@ -594,7 +594,7 @@ public static T Single<T>(this IReadOnlyList<T> list, Func<T, bool> predicate)
             {
                 if (firstSeen)
                 {
-                    return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_matching_element);
+                    return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_matching_element);
                 }
 
                 firstSeen = true;
@@ -604,7 +604,7 @@ public static T Single<T>(this IReadOnlyList<T> list, Func<T, bool> predicate)
 
         if (!firstSeen)
         {
-            return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_matching_elements);
+            return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_matching_elements);
         }
 
         return result!;
@@ -643,7 +643,7 @@ public static T Single<T, TArg>(this IReadOnlyList<T> list, TArg arg, Func<T, TA
             {
                 if (firstSeen)
                 {
-                    return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_matching_element);
+                    return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_matching_element);
                 }
 
                 firstSeen = true;
@@ -653,7 +653,7 @@ public static T Single<T, TArg>(this IReadOnlyList<T> list, TArg arg, Func<T, TA
 
         if (!firstSeen)
         {
-            return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_no_matching_elements);
+            return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_no_matching_elements);
         }
 
         return result!;
@@ -679,7 +679,7 @@ public static T Single<T, TArg>(this IReadOnlyList<T> list, TArg arg, Func<T, TA
         {
             1 => list[0],
             0 => default,
-            _ => ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_element)
+            _ => ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_element)
         };
     }
 
@@ -706,7 +706,7 @@ public static T SingleOrDefault<T>(this IReadOnlyList<T> list, T defaultValue)
         {
             1 => list[0],
             0 => defaultValue,
-            _ => ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_element)
+            _ => ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_element)
         };
     }
 
@@ -738,7 +738,7 @@ public static T SingleOrDefault<T>(this IReadOnlyList<T> list, T defaultValue)
             {
                 if (firstSeen)
                 {
-                    return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_matching_element);
+                    return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_matching_element);
                 }
 
                 firstSeen = true;
@@ -780,7 +780,7 @@ public static T SingleOrDefault<T>(this IReadOnlyList<T> list, T defaultValue)
             {
                 if (firstSeen)
                 {
-                    return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_matching_element);
+                    return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_matching_element);
                 }
 
                 firstSeen = true;
@@ -822,7 +822,7 @@ public static T SingleOrDefault<T>(this IReadOnlyList<T> list, Func<T, bool> pre
             {
                 if (firstSeen)
                 {
-                    return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_matching_element);
+                    return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_matching_element);
                 }
 
                 firstSeen = true;
@@ -867,7 +867,7 @@ public static T SingleOrDefault<T, TArg>(this IReadOnlyList<T> list, TArg arg, F
             {
                 if (firstSeen)
                 {
-                    return ThrowHelper.ThrowInvalidOperation<T>(SR.Contains_more_than_one_matching_element);
+                    return ThrowHelper.ThrowInvalidOperationException<T>(SR.Contains_more_than_one_matching_element);
                 }
 
                 firstSeen = true;
diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
index 3c766ce6a07..b6be700d097 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
@@ -4,8 +4,7 @@
 using System.Diagnostics.CodeAnalysis;
 
 #if !NET
-using ArgHelper = Microsoft.AspNetCore.Razor.ArgHelper;
-using ThrowHelper = Microsoft.AspNetCore.Razor.Utilities.ThrowHelper;
+using Microsoft.AspNetCore.Razor;
 #endif
 
 namespace System;
@@ -73,7 +72,7 @@ public static ReadOnlySpan<char> AsSpan(this string? text, Index startIndex)
         {
             if (!startIndex.Equals(Index.Start))
             {
-                ThrowHelper.ThrowArgumentOutOfRange(nameof(startIndex));
+                ThrowHelper.ThrowArgumentOutOfRangeException(nameof(startIndex));
             }
 
             return default;
@@ -111,7 +110,7 @@ public static ReadOnlySpan<char> AsSpan(this string? text, Range range)
         {
             if (!range.Start.Equals(Index.Start) || !range.End.Equals(Index.Start))
             {
-                ThrowHelper.ThrowArgumentNull(nameof(text));
+                ThrowHelper.ThrowArgumentNullException(nameof(text));
             }
 
             return default;
@@ -251,7 +250,7 @@ public static ReadOnlyMemory<char> AsMemory(this string? text, Index startIndex)
         {
             if (!startIndex.Equals(Index.Start))
             {
-                ThrowHelper.ThrowArgumentOutOfRange(nameof(startIndex));
+                ThrowHelper.ThrowArgumentOutOfRangeException(nameof(startIndex));
             }
 
             return default;
@@ -289,7 +288,7 @@ public static ReadOnlyMemory<char> AsMemory(this string? text, Range range)
         {
             if (!range.Start.Equals(Index.Start) || !range.End.Equals(Index.Start))
             {
-                ThrowHelper.ThrowArgumentNull(nameof(text));
+                ThrowHelper.ThrowArgumentNullException(nameof(text));
             }
 
             return default;
diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ThrowHelper.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ThrowHelper.cs
new file mode 100644
index 00000000000..20d3dc45321
--- /dev/null
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/ThrowHelper.cs
@@ -0,0 +1,235 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.AspNetCore.Razor;
+
+internal static class ThrowHelper
+{
+    /// <summary>
+    ///  Throws an <see cref="ArgumentException"/> with a parameter name and a message.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <param name="message">
+    ///  The message to include in the exception.
+    /// </param>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ThrowArgumentException(string? paramName, string message)
+        => throw new ArgumentException(message, paramName);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentException"/> with a parameter name and a message.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <param name="message">
+    ///  The message to include in the exception.
+    /// </param>
+    /// <returns>
+    ///  This method does not return because it always throws an exception, but it is defined to return a
+    ///  <typeparamref name="T"/> value. This is useful for control flow scenarios where it is necessary to
+    ///  throw an exception and return from a method.
+    /// </returns>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static T ThrowArgumentException<T>(string? paramName, string message)
+        => throw new ArgumentException(message, paramName);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentNullException"/> with a parameter name.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ThrowArgumentNullException(string? paramName)
+        => throw new ArgumentNullException(paramName);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentNullException"/> with a parameter name.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <returns>
+    ///  This method does not return because it always throws an exception, but it is defined to return a
+    ///  <typeparamref name="T"/> value. This is useful for control flow scenarios where it is necessary to
+    ///  throw an exception and return from a method.
+    /// </returns>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static T ThrowArgumentNullException<T>(string? paramName)
+        => throw new ArgumentNullException(paramName);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentOutOfRangeException"/> with a parameter name, message, and
+    ///  the actual invalid value.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <param name="actualValue">
+    ///  The actual invalid value to include in the exception.
+    /// </param>
+    /// <param name="message">
+    ///  The message to include in the exception.
+    /// </param>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ThrowArgumentOutOfRangeException(string? paramName, object? actualValue, string message)
+        => throw new ArgumentOutOfRangeException(paramName, actualValue, message);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentOutOfRangeException"/> with a parameter name and message.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <param name="message">
+    ///  The message to include in the exception.
+    /// </param>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ThrowArgumentOutOfRangeException(string? paramName, string message)
+        => throw new ArgumentOutOfRangeException(paramName, message);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentOutOfRangeException"/> with a parameter name.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ThrowArgumentOutOfRangeException(string? paramName)
+        => throw new ArgumentOutOfRangeException(paramName);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentOutOfRangeException"/> with a parameter name, message, and
+    ///  the actual invalid value.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <param name="actualValue">
+    ///  The actual invalid value to include in the exception.
+    /// </param>
+    /// <param name="message">
+    ///  The message to include in the exception.
+    /// </param>
+    /// <returns>
+    ///  This method does not return because it always throws an exception, but it is defined to return a
+    ///  <typeparamref name="T"/> value. This is useful for control flow scenarios where it is necessary to
+    ///  throw an exception and return from a method.
+    /// </returns>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static T ThrowArgumentOutOfRangeException<T>(string? paramName, object? actualValue, string message)
+        => throw new ArgumentOutOfRangeException(paramName, actualValue, message);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentOutOfRangeException"/> with a parameter name and message.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <param name="message">
+    ///  The message to include in the exception.
+    /// </param>
+    /// <returns>
+    ///  This method does not return because it always throws an exception, but it is defined to return a
+    ///  <typeparamref name="T"/> value. This is useful for control flow scenarios where it is necessary to
+    ///  throw an exception and return from a method.
+    /// </returns>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static T ThrowArgumentOutOfRangeException<T>(string? paramName, string message)
+        => throw new ArgumentOutOfRangeException(paramName, message);
+
+    /// <summary>
+    ///  Throws an <see cref="ArgumentOutOfRangeException"/> with a parameter name.
+    /// </summary>
+    /// <param name="paramName">
+    ///  The parameter name to include in the exception.
+    /// </param>
+    /// <returns>
+    ///  This method does not return because it always throws an exception, but it is defined to return a
+    ///  <typeparamref name="T"/> value. This is useful for control flow scenarios where it is necessary to
+    ///  throw an exception and return from a method.
+    /// </returns>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static T ThrowArgumentOutOfRangeException<T>(string? paramName)
+        => throw new ArgumentOutOfRangeException(paramName);
+
+    /// <summary>
+    ///  Throws an <see cref="InvalidOperationException"/> with a message.
+    /// </summary>
+    /// <param name="message">
+    ///  The message to include in the exception.
+    /// </param>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ThrowInvalidOperationException(string message)
+        => throw new InvalidOperationException(message);
+
+    /// <summary>
+    ///  Throws an <see cref="InvalidOperationException"/> with a message.
+    /// </summary>
+    /// <param name="message">
+    ///  The message to include in the exception.
+    /// </param>
+    /// <returns>
+    ///  This method does not return because it always throws an exception, but it is defined to return a
+    ///  <typeparamref name="T"/> value. This is useful for control flow scenarios where it is necessary to
+    ///  throw an exception and return from a method.
+    /// </returns>
+    /// <remarks>
+    ///  This helps the JIT inline methods that need to throw an exceptions.
+    /// </remarks>
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static T ThrowInvalidOperationException<T>(string message)
+        => throw new InvalidOperationException(message);
+}
diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/Utilities/ThrowHelper.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/Utilities/ThrowHelper.cs
deleted file mode 100644
index 168871c0218..00000000000
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/Utilities/ThrowHelper.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the MIT license. See License.txt in the project root for license information.
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-
-namespace Microsoft.AspNetCore.Razor.Utilities;
-
-internal static class ThrowHelper
-{
-    /// <summary>
-    ///  This is present to help the JIT inline methods that need to throw an <see cref="InvalidOperationException"/>.
-    /// </summary>
-    [DoesNotReturn]
-    public static void ThrowArgumentNull(string paramName)
-        => throw new ArgumentNullException(paramName);
-
-    /// <summary>
-    ///  This is present to help the JIT inline methods that need to throw an <see cref="InvalidOperationException"/>.
-    /// </summary>
-    [DoesNotReturn]
-    public static T ThrowArgumentNull<T>(string paramName)
-        => throw new ArgumentNullException(paramName);
-
-    /// <summary>
-    ///  This is present to help the JIT inline methods that need to throw an <see cref="InvalidOperationException"/>.
-    /// </summary>
-    [DoesNotReturn]
-    public static void ThrowArgumentOutOfRange(string paramName)
-        => throw new ArgumentOutOfRangeException(paramName);
-
-    /// <summary>
-    ///  This is present to help the JIT inline methods that need to throw an <see cref="InvalidOperationException"/>.
-    /// </summary>
-    [DoesNotReturn]
-    public static T ThrowArgumentOutOfRange<T>(string paramName)
-        => throw new ArgumentOutOfRangeException(paramName);
-
-    /// <summary>
-    ///  This is present to help the JIT inline methods that need to throw an <see cref="InvalidOperationException"/>.
-    /// </summary>
-    [DoesNotReturn]
-    public static T ThrowInvalidOperation<T>(string message)
-        => throw new InvalidOperationException(message);
-}

From 749ded88f0cb950171f64f31574ef830049b214e Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Fri, 19 Jul 2024 12:15:56 -0700
Subject: [PATCH 15/16] Add XML doc comments for StreamExtensions.CreateString
 and SpanAction

---
 .../StringExtensions.cs                       | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
index b6be700d097..393a2626403 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/StringExtensions.cs
@@ -555,8 +555,47 @@ public static bool EndsWith(this string text, char value)
 #endif
     }
 
+    /// <summary>
+    ///  Encapsulates a method that receives a span of objects of type <typeparamref name="T"/>
+    ///  and a state object of type <typeparamref name="TArg"/>.
+    /// </summary>
+    /// <typeparam name="T">
+    ///  The type of the objects in the span.
+    /// </typeparam>
+    /// <typeparam name="TArg">
+    ///  The type of the object that represents the state.
+    /// </typeparam>
+    /// <param name="span">
+    ///  A span of objects of type <typeparamref name="T"/>.
+    /// </param>
+    /// <param name="arg">
+    ///  A state object of type <typeparamref name="TArg"/>.
+    /// </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)
     {
 #if NET

From fabbeeb5c0b09fedec189c1ba6009678acbd8bf4 Mon Sep 17 00:00:00 2001
From: Dustin Campbell <dustin@teamcampbell.org>
Date: Fri, 19 Jul 2024 12:39:26 -0700
Subject: [PATCH 16/16] Clean up MemoryBuilder<T>.Grow when checking again
 ArrayMaxLength

---
 .../MemoryBuilder`1.cs                                    | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
index a40d40ea5b0..cc9c236f32b 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared/MemoryBuilder`1.cs
@@ -118,9 +118,11 @@ private void Grow(int additionalCapacityRequired = 1)
         // we've grown too large, we want to OOM when Rent is called below.
         if ((uint)nextCapacity > ArrayMaxLength)
         {
-            nextCapacity = Math.Max(
-                Math.Max(_memory.Length + 1, ArrayMaxLength),
-                _memory.Length);
+            // Note: it's not possible for _memory.Length + 1 to overflow because that would mean
+            // _memory is pointing to an array with length int.MaxValue, which is larger than
+            // Array.MaxLength. We would have OOM'd before getting here.
+
+            nextCapacity = Math.Max(_memory.Length + 1, ArrayMaxLength);
         }
 
         Debug.Assert(nextCapacity > _memory.Length);