From ea500de5dd6b6ac80edf175b1a8ca4e2af4832e5 Mon Sep 17 00:00:00 2001
From: Gen Lu <genlu@users.noreply.github.com>
Date: Thu, 29 Feb 2024 14:35:11 -0800
Subject: [PATCH 001/170] Bump patch version for NuGet publish purpsoe

---
 eng/Versions.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/Versions.props b/eng/Versions.props
index 3c81e1c73d88e..9035bbe250bf3 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -7,7 +7,7 @@
   <PropertyGroup>
     <MajorVersion>4</MajorVersion>
     <MinorVersion>9</MinorVersion>
-    <PatchVersion>0</PatchVersion>
+    <PatchVersion>2</PatchVersion>
     <PreReleaseVersionLabel>3</PreReleaseVersionLabel>
     <VersionPrefix>$(MajorVersion).$(MinorVersion).$(PatchVersion)</VersionPrefix>
     <!--

From 2c0d29fd84a118881be2a7ec49cb6f3534107565 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Tue, 5 Mar 2024 12:10:39 +1100
Subject: [PATCH 002/170] Expose semantic tokens functionality to Razor EA

---
 .../SemanticTokens/SemanticTokensHelpers.cs   | 75 ++++++++++++-------
 .../SemanticTokensRangeTests.cs               | 31 ++++----
 src/Features/Lsif/Generator/Generator.cs      |  4 +-
 .../Cohost/Handlers/SemanticTokensRange.cs    | 37 +++++++++
 4 files changed, 104 insertions(+), 43 deletions(-)
 create mode 100644 src/Tools/ExternalAccess/Razor/Cohost/Handlers/SemanticTokensRange.cs

diff --git a/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs b/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
index af20b656bea90..df56d6e280e2f 100644
--- a/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
@@ -15,13 +15,12 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
-using Roslyn.LanguageServer.Protocol;
 using Roslyn.Utilities;
 using LSP = Roslyn.LanguageServer.Protocol;
 
 namespace Microsoft.CodeAnalysis.LanguageServer.Handler.SemanticTokens
 {
-    internal class SemanticTokensHelpers
+    internal static class SemanticTokensHelpers
     {
         internal static async Task<int[]> HandleRequestHelperAsync(
             IGlobalOptionService globalOptions,
@@ -36,44 +35,57 @@ internal static async Task<int[]> HandleRequestHelperAsync(
             }
 
             var contextDocument = context.GetRequiredDocument();
+            var project = contextDocument.Project;
+            var options = globalOptions.GetClassificationOptions(project.Language);
+            var supportsVisualStudioExtensions = context.GetRequiredClientCapabilities().HasVisualStudioLspCapability();
 
+            using var _ = ArrayBuilder<LinePositionSpan>.GetInstance(ranges.Length, out var spans);
+            foreach (var range in ranges)
+            {
+                spans.Add(ProtocolConversions.RangeToLinePositionSpan(range));
+            }
+
+            var tokensData = await HandleRequestHelperAsync(contextDocument, spans.ToImmutable(), supportsVisualStudioExtensions, options, cancellationToken).ConfigureAwait(false);
+
+            // The above call to get semantic tokens may be inaccurate (because we use frozen partial semantics).  Kick
+            // off a request to ensure that the OOP side gets a fully up to compilation for this project.  Once it does
+            // we can optionally choose to notify our caller to do a refresh if we computed a compilation for a new
+            // solution snapshot.
+            await semanticTokensRefreshQueue.TryEnqueueRefreshComputationAsync(project, cancellationToken).ConfigureAwait(false);
+            return tokensData;
+        }
+
+        public static async Task<int[]> HandleRequestHelperAsync( Document document, ImmutableArray<LinePositionSpan> spans, bool supportsVisualStudioExtensions, ClassificationOptions options, CancellationToken cancellationToken)
+        {
             // If the full compilation is not yet available, we'll try getting a partial one. It may contain inaccurate
             // results but will speed up how quickly we can respond to the client's request.
-            var document = contextDocument.WithFrozenPartialSemantics(cancellationToken);
-            var project = document.Project;
-            var options = globalOptions.GetClassificationOptions(project.Language) with { ForceFrozenPartialSemanticsForCrossProcessOperations = true };
+            document = document.WithFrozenPartialSemantics(cancellationToken);
+            options = options with { ForceFrozenPartialSemanticsForCrossProcessOperations = true };
 
             // The results from the range handler should not be cached since we don't want to cache
             // partial token results. In addition, a range request is only ever called with a whole
             // document request, so caching range results is unnecessary since the whole document
             // handler will cache the results anyway.
-            var capabilities = context.GetRequiredClientCapabilities();
-            var tokensData = await SemanticTokensHelpers.ComputeSemanticTokensDataAsync(
-                capabilities,
+            return await ComputeSemanticTokensDataAsync(
                 document,
-                ranges,
+                spans,
+                supportsVisualStudioExtensions,
                 options,
                 cancellationToken).ConfigureAwait(false);
-
-            // The above call to get semantic tokens may be inaccurate (because we use frozen partial semantics).  Kick
-            // off a request to ensure that the OOP side gets a fully up to compilation for this project.  Once it does
-            // we can optionally choose to notify our caller to do a refresh if we computed a compilation for a new
-            // solution snapshot.
-            await semanticTokensRefreshQueue.TryEnqueueRefreshComputationAsync(project, cancellationToken).ConfigureAwait(false);
-            return tokensData;
         }
 
         /// <summary>
         /// Returns the semantic tokens data for a given document with an optional ranges.
         /// </summary>
+        /// <param name="spans">Spans to compute tokens for. If empty, the whole document will be used.</param>
         public static async Task<int[]> ComputeSemanticTokensDataAsync(
-            ClientCapabilities capabilities,
             Document document,
-            LSP.Range[]? ranges,
+            ImmutableArray<LinePositionSpan> spans,
+            bool supportsVisualStudioExtensions,
             ClassificationOptions options,
             CancellationToken cancellationToken)
         {
-            var tokenTypesToIndex = SemanticTokensSchema.GetSchema(capabilities.HasVisualStudioLspCapability()).TokenTypeToIndex;
+            var tokenTypesToIndex = SemanticTokensSchema.GetSchema(supportsVisualStudioExtensions).TokenTypeToIndex;
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var text = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
             using var _1 = Classifier.GetPooledList(out var classifiedSpans);
@@ -81,15 +93,24 @@ public static async Task<int[]> ComputeSemanticTokensDataAsync(
 
             // We either calculate the tokens for the full document span, or the user 
             // can pass in a range from the full document if they wish.
-            ranges ??= [ProtocolConversions.TextSpanToRange(root.FullSpan, text)];
-            using var _ = ArrayBuilder<TextSpan>.GetInstance(ranges.Length, out var textSpans);
-            foreach (var range in ranges)
+            ImmutableArray<TextSpan> textSpans;
+            if (spans.Length == 0)
+            {
+                textSpans = [root.FullSpan];
+            }
+            else
             {
-                textSpans.Add(ProtocolConversions.RangeToTextSpan(range, text));
+                using var _ = ArrayBuilder<TextSpan>.GetInstance(spans.Length, out var textSpansBuilder);
+                foreach (var span in spans)
+                {
+                    textSpansBuilder.Add(text.Lines.GetTextSpan(span));
+                }
+
+                textSpans = textSpansBuilder.ToImmutable();
             }
 
             await GetClassifiedSpansForDocumentAsync(
-                classifiedSpans, document, textSpans.ToImmutableArray(), options, cancellationToken).ConfigureAwait(false);
+                classifiedSpans, document, textSpans, options, cancellationToken).ConfigureAwait(false);
 
             // Classified spans are not guaranteed to be returned in a certain order so we sort them to be safe.
             classifiedSpans.Sort(ClassifiedSpanComparer.Instance);
@@ -100,7 +121,7 @@ await GetClassifiedSpansForDocumentAsync(
 
             // TO-DO: We should implement support for streaming if LSP adds support for it:
             // https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1276300
-            return ComputeTokens(capabilities, text.Lines, updatedClassifiedSpans, tokenTypesToIndex);
+            return ComputeTokens(text.Lines, updatedClassifiedSpans, supportsVisualStudioExtensions, tokenTypesToIndex);
         }
 
         private static async Task GetClassifiedSpansForDocumentAsync(
@@ -214,9 +235,9 @@ static void ConvertToSingleLineSpan(
         }
 
         private static int[] ComputeTokens(
-            ClientCapabilities capabilities,
             TextLineCollection lines,
             SegmentedList<ClassifiedSpan> classifiedSpans,
+            bool supportsVisualStudioExtensions,
             IReadOnlyDictionary<string, int> tokenTypesToIndex)
         {
             using var _ = ArrayBuilder<int>.GetInstance(classifiedSpans.Count, out var data);
@@ -226,7 +247,7 @@ private static int[] ComputeTokens(
             var lastLineNumber = 0;
             var lastStartCharacter = 0;
 
-            var tokenTypeMap = SemanticTokensSchema.GetSchema(capabilities.HasVisualStudioLspCapability()).TokenTypeMap;
+            var tokenTypeMap = SemanticTokensSchema.GetSchema(supportsVisualStudioExtensions).TokenTypeMap;
 
             for (var currentClassifiedSpanIndex = 0; currentClassifiedSpanIndex < classifiedSpans.Count; currentClassifiedSpanIndex++)
             {
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/SemanticTokens/SemanticTokensRangeTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/SemanticTokens/SemanticTokensRangeTests.cs
index 26101d1f2de54..34ff01d65aa4e 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/SemanticTokens/SemanticTokensRangeTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/SemanticTokens/SemanticTokensRangeTests.cs
@@ -2,11 +2,13 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
 using Microsoft.CodeAnalysis.LanguageServer.Handler.SemanticTokens;
+using Microsoft.CodeAnalysis.Text;
 using Roslyn.LanguageServer.Protocol;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -118,13 +120,14 @@ private void __RazorDirectiveTokenHelpers__() {
                 markup, mutatingLspWorkspace, GetCapabilities(isVS));
 
             var document = testLspServer.GetCurrentSolution().Projects.First().Documents.First();
-            var ranges = new LSP.Range[2] {
-                new LSP.Range { Start = new Position(12, 0), End = new Position(13, 0) },
-                new LSP.Range { Start = new Position(29, 0), End = new Position(30, 0) }
-            };
+            ImmutableArray<LinePositionSpan> spans = [
+                new LinePositionSpan(new LinePosition(12, 0), new LinePosition(13, 0)),
+                new LinePositionSpan(new LinePosition(29, 0), new LinePosition(30, 0)),
+            ];
+
             var options = ClassificationOptions.Default;
             var results = await SemanticTokensHelpers.ComputeSemanticTokensDataAsync(
-                testLspServer.ClientCapabilities, document, ranges, options, CancellationToken.None);
+                document, spans, isVS, options, CancellationToken.None);
 
             var expectedResults = new LSP.SemanticTokens();
             var tokenTypeToIndex = GetTokenTypeToIndex(testLspServer);
@@ -175,10 +178,10 @@ static class C { }
                 markup, mutatingLspWorkspace, GetCapabilities(isVS));
 
             var document = testLspServer.GetCurrentSolution().Projects.First().Documents.First();
-            var ranges = new[] { new LSP.Range { Start = new Position(1, 0), End = new Position(2, 0) } };
+            ImmutableArray<LinePositionSpan> spans = [new LinePositionSpan(new LinePosition(1, 0), new LinePosition(2, 0))];
             var options = ClassificationOptions.Default;
             var results = await SemanticTokensHelpers.ComputeSemanticTokensDataAsync(
-                testLspServer.ClientCapabilities, document, ranges, options, CancellationToken.None);
+                document, spans, isVS, options, CancellationToken.None);
 
             var expectedResults = new LSP.SemanticTokens();
             var tokenTypeToIndex = GetTokenTypeToIndex(testLspServer);
@@ -225,10 +228,10 @@ public async Task TestGetSemanticTokensRange_MultiLineComment_IncludeSyntacticCl
                 markup, mutatingLspWorkspace, GetCapabilities(isVS));
 
             var document = testLspServer.GetCurrentSolution().Projects.First().Documents.First();
-            var ranges = new[] { new LSP.Range { Start = new Position(0, 0), End = new Position(4, 0) } };
+            ImmutableArray<LinePositionSpan> spans = [new LinePositionSpan(new LinePosition(0, 0), new LinePosition(4, 0))];
             var options = ClassificationOptions.Default;
             var results = await SemanticTokensHelpers.ComputeSemanticTokensDataAsync(
-                testLspServer.ClientCapabilities, document, ranges, options, CancellationToken.None);
+                document, spans, isVS, options, CancellationToken.None);
 
             var expectedResults = new LSP.SemanticTokens();
             var tokenTypeToIndex = GetTokenTypeToIndex(testLspServer);
@@ -284,10 +287,10 @@ void M()
                 markup, mutatingLspWorkspace, GetCapabilities(isVS));
 
             var document = testLspServer.GetCurrentSolution().Projects.First().Documents.First();
-            var ranges = new[] { new LSP.Range { Start = new Position(0, 0), End = new Position(9, 0) } };
+            ImmutableArray<LinePositionSpan> spans = [new LinePositionSpan(new LinePosition(0, 0), new LinePosition(9, 0))];
             var options = ClassificationOptions.Default;
             var results = await SemanticTokensHelpers.ComputeSemanticTokensDataAsync(
-                testLspServer.ClientCapabilities, document, ranges, options, CancellationToken.None);
+                document, spans, isVS, options, CancellationToken.None);
 
             var expectedResults = new LSP.SemanticTokens();
             var tokenTypeToIndex = GetTokenTypeToIndex(testLspServer);
@@ -365,10 +368,10 @@ void M()
                 markup, mutatingLspWorkspace, GetCapabilities(isVS));
 
             var document = testLspServer.GetCurrentSolution().Projects.First().Documents.First();
-            var ranges = new[] { new LSP.Range { Start = new Position(0, 0), End = new Position(9, 0) } };
+            ImmutableArray<LinePositionSpan> spans = [new LinePositionSpan(new LinePosition(0, 0), new LinePosition(9, 0))];
             var options = ClassificationOptions.Default;
             var results = await SemanticTokensHelpers.ComputeSemanticTokensDataAsync(
-                testLspServer.ClientCapabilities, document, ranges, options, CancellationToken.None);
+                document, spans, isVS, options, CancellationToken.None);
 
             var expectedResults = new LSP.SemanticTokens();
             var tokenTypeToIndex = GetTokenTypeToIndex(testLspServer);
@@ -476,7 +479,7 @@ void M()
             var document = testLspServer.GetCurrentSolution().Projects.First().Documents.First();
             var options = ClassificationOptions.Default;
             var results = await SemanticTokensHelpers.ComputeSemanticTokensDataAsync(
-                testLspServer.ClientCapabilities, document, ranges: null, options: options, cancellationToken: CancellationToken.None);
+                document, spans: [], isVS, options: options, cancellationToken: CancellationToken.None);
 
             var expectedResults = new LSP.SemanticTokens();
 
diff --git a/src/Features/Lsif/Generator/Generator.cs b/src/Features/Lsif/Generator/Generator.cs
index 7439a53f8b431..61929ec437f86 100644
--- a/src/Features/Lsif/Generator/Generator.cs
+++ b/src/Features/Lsif/Generator/Generator.cs
@@ -482,9 +482,9 @@ private static async Task GenerateSemanticTokensAsync(
             // include syntax tokens in the generated data.
             var data = await SemanticTokensHelpers.ComputeSemanticTokensDataAsync(
                 // Just get the pure-lsp semantic tokens here.
-                new VSInternalClientCapabilities { SupportsVisualStudioExtensions = true },
                 document,
-                ranges: null,
+                spans: [],
+                supportsVisualStudioExtensions: true,
                 options: Classification.ClassificationOptions.Default,
                 cancellationToken: CancellationToken.None);
 
diff --git a/src/Tools/ExternalAccess/Razor/Cohost/Handlers/SemanticTokensRange.cs b/src/Tools/ExternalAccess/Razor/Cohost/Handlers/SemanticTokensRange.cs
new file mode 100644
index 0000000000000..2358c142b3c61
--- /dev/null
+++ b/src/Tools/ExternalAccess/Razor/Cohost/Handlers/SemanticTokensRange.cs
@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.LanguageServer.Handler.SemanticTokens;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost.Handlers
+{
+    internal static class SemanticTokensRange
+    {
+        public static Task<int[]> GetSemanticTokensAsync(
+            Document document,
+            ImmutableArray<LinePositionSpan> spans,
+            bool supportsVisualStudioExtensions,
+            CancellationToken cancellationToken)
+        {
+            var tokens = SemanticTokensHelpers.HandleRequestHelperAsync(
+                        document,
+                        spans,
+                        supportsVisualStudioExtensions,
+                        ClassificationOptions.Default,
+                        cancellationToken);
+
+            // The above call to get semantic tokens may be inaccurate (because we use frozen partial semantics).  Kick
+            // off a request to ensure that the OOP side gets a fully up to compilation for this project.  Once it does
+            // we can optionally choose to notify our caller to do a refresh if we computed a compilation for a new
+            // solution snapshot.
+            // TODO: await semanticTokensRefreshQueue.TryEnqueueRefreshComputationAsync(project, cancellationToken).ConfigureAwait(false);
+            return tokens;
+        }
+    }
+}

From 28bf4cf06c2ba2a919a97b9a4431dab3a2cc6adb Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Mon, 26 Feb 2024 15:42:08 -0600
Subject: [PATCH 003/170] Add SegmentedCollectionsMarshal

---
 ...ntedDictionary`2+Builder+PrivateMarshal.cs |  21 ++
 ...egmentedDictionary`2+PrivateInterlocked.cs |  15 +-
 ...leSegmentedHashSet`1+PrivateInterlocked.cs |  11 +-
 ...tableSegmentedList`1+PrivateInterlocked.cs |  11 +-
 ...crosoft.CodeAnalysis.Collections.projitems |   3 +
 .../SegmentedCollectionsMarshal.cs            | 195 ++++++++++++++++++
 .../SegmentedDictionary`2+PrivateMarshal.cs   |  18 ++
 .../Collections/SegmentedDictionary`2.cs      |   2 +-
 8 files changed, 272 insertions(+), 4 deletions(-)
 create mode 100644 src/Dependencies/Collections/ImmutableSegmentedDictionary`2+Builder+PrivateMarshal.cs
 create mode 100644 src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
 create mode 100644 src/Dependencies/Collections/SegmentedDictionary`2+PrivateMarshal.cs

diff --git a/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+Builder+PrivateMarshal.cs b/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+Builder+PrivateMarshal.cs
new file mode 100644
index 0000000000000..f2d3c6cff5f6e
--- /dev/null
+++ b/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+Builder+PrivateMarshal.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.Collections;
+
+internal readonly partial struct ImmutableSegmentedDictionary<TKey, TValue>
+{
+    public partial class Builder
+    {
+        /// <summary>
+        /// Private helper class for use only by <see cref="SegmentedCollectionsMarshal"/>.
+        /// </summary>
+        internal static class PrivateMarshal
+        {
+            /// <inheritdoc cref="SegmentedCollectionsMarshal.GetValueRefOrNullRef{TKey, TValue}(ImmutableSegmentedDictionary{TKey, TValue}.Builder, TKey)"/>
+            public static ref TValue FindValue(Builder dictionary, TKey key)
+                => ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dictionary.GetOrCreateMutableDictionary(), key);
+        }
+    }
+}
diff --git a/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateInterlocked.cs b/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateInterlocked.cs
index 68d2e03d8544c..b45f1b375cf11 100644
--- a/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateInterlocked.cs
+++ b/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateInterlocked.cs
@@ -10,7 +10,8 @@ namespace Microsoft.CodeAnalysis.Collections
     internal readonly partial struct ImmutableSegmentedDictionary<TKey, TValue>
     {
         /// <summary>
-        /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/>.
+        /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/> and
+        /// <see cref="SegmentedCollectionsMarshal"/>.
         /// </summary>
         internal static class PrivateInterlocked
         {
@@ -40,6 +41,18 @@ internal static ImmutableSegmentedDictionary<TKey, TValue> InterlockedCompareExc
 
                 return new ImmutableSegmentedDictionary<TKey, TValue>(dictionary);
             }
+
+            /// <inheritdoc cref="SegmentedCollectionsMarshal.GetValueRefOrNullRef{TKey, TValue}(ImmutableSegmentedDictionary{TKey, TValue}, TKey)"/>
+            public static ref readonly TValue FindValue(ImmutableSegmentedDictionary<TKey, TValue> dictionary, TKey key)
+                => ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dictionary._dictionary, key);
+
+            /// <inheritdoc cref="SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary{TKey, TValue}(SegmentedDictionary{TKey, TValue}?)"/>
+            internal static ImmutableSegmentedDictionary<TKey, TValue> AsImmutableSegmentedDictionary(SegmentedDictionary<TKey, TValue>? dictionary)
+                => dictionary is not null ? new ImmutableSegmentedDictionary<TKey, TValue>(dictionary) : default;
+
+            /// <inheritdoc cref="SegmentedCollectionsMarshal.AsSegmentedDictionary{TKey, TValue}(ImmutableSegmentedDictionary{TKey, TValue})"/>
+            internal static SegmentedDictionary<TKey, TValue>? AsSegmentedDictionary(ImmutableSegmentedDictionary<TKey, TValue> dictionary)
+                => dictionary._dictionary;
         }
     }
 }
diff --git a/src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateInterlocked.cs b/src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateInterlocked.cs
index 04b9cfb74d6cf..dcb0acb0e3499 100644
--- a/src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateInterlocked.cs
+++ b/src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateInterlocked.cs
@@ -10,7 +10,8 @@ namespace Microsoft.CodeAnalysis.Collections
     internal readonly partial struct ImmutableSegmentedHashSet<T>
     {
         /// <summary>
-        /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/>.
+        /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/> and
+        /// <see cref="SegmentedCollectionsMarshal"/>.
         /// </summary>
         internal static class PrivateInterlocked
         {
@@ -40,6 +41,14 @@ internal static ImmutableSegmentedHashSet<T> InterlockedCompareExchange(ref Immu
 
                 return new ImmutableSegmentedHashSet<T>(set);
             }
+
+            /// <inheritdoc cref="SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet{T}(SegmentedHashSet{T}?)"/>
+            internal static ImmutableSegmentedHashSet<T> AsImmutableSegmentedHashSet(SegmentedHashSet<T>? set)
+                => set is not null ? new ImmutableSegmentedHashSet<T>(set) : default;
+
+            /// <inheritdoc cref="SegmentedCollectionsMarshal.AsSegmentedHashSet{T}(ImmutableSegmentedHashSet{T})"/>
+            internal static SegmentedHashSet<T>? AsSegmentedHashSet(ImmutableSegmentedHashSet<T> set)
+                => set._set;
         }
     }
 }
diff --git a/src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateInterlocked.cs b/src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateInterlocked.cs
index 916c025c55b76..871ac2535fbf1 100644
--- a/src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateInterlocked.cs
+++ b/src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateInterlocked.cs
@@ -10,7 +10,8 @@ namespace Microsoft.CodeAnalysis.Collections
     internal partial struct ImmutableSegmentedList<T>
     {
         /// <summary>
-        /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/>.
+        /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/> and
+        /// <see cref="SegmentedCollectionsMarshal"/>.
         /// </summary>
         internal static class PrivateInterlocked
         {
@@ -40,6 +41,14 @@ internal static ImmutableSegmentedList<T> InterlockedCompareExchange(ref Immutab
 
                 return new ImmutableSegmentedList<T>(list);
             }
+
+            /// <inheritdoc cref="SegmentedCollectionsMarshal.AsImmutableSegmentedList{T}(SegmentedList{T}?)"/>
+            internal static ImmutableSegmentedList<T> AsImmutableSegmentedList(SegmentedList<T>? list)
+                => list is not null ? new ImmutableSegmentedList<T>(list) : default;
+
+            /// <inheritdoc cref="SegmentedCollectionsMarshal.AsSegmentedList{T}(ImmutableSegmentedList{T})"/>
+            internal static SegmentedList<T>? AsSegmentedList(ImmutableSegmentedList<T> list)
+                => list._list;
         }
     }
 }
diff --git a/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems b/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
index 45608e695a754..a8a099456ae40 100644
--- a/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
+++ b/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
@@ -12,6 +12,7 @@
   <ItemGroup>
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+Builder+KeyCollection.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+Builder+PrivateMarshal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+Builder+ValueCollection.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+Builder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+Enumerator.cs" />
@@ -53,6 +54,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)RoslynImmutableInterlocked.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedArray.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedArray`1.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)SegmentedCollectionsMarshal.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)SegmentedDictionary`2+PrivateMarshal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedDictionary`2.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedHashSet`1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedList`1.cs" />
diff --git a/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs b/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
new file mode 100644
index 0000000000000..e95a4463196aa
--- /dev/null
+++ b/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
@@ -0,0 +1,195 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.CodeAnalysis.Collections;
+
+/// <summary>
+/// An unsafe class that provides a set of methods to access the underlying data representations of immutable segmented
+/// collections.
+/// </summary>
+internal static class SegmentedCollectionsMarshal
+{
+    /// <summary>
+    /// Gets either a ref to a <typeparamref name="TValue"/> in the <see cref="SegmentedDictionary{TKey, TValue}"/> or a
+    /// ref null if it does not exist in the <paramref name="dictionary"/>.
+    /// </summary>
+    /// <param name="dictionary">The dictionary to get the ref to <typeparamref name="TValue"/> from.</param>
+    /// <param name="key">The key used for lookup.</param>
+    /// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
+    /// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
+    /// <remarks>
+    /// Items should not be added or removed from the <see cref="SegmentedDictionary{TKey, TValue}"/> while the ref
+    /// <typeparamref name="TValue"/> is in use. The ref null can be detected using <see cref="M:System.Runtime.CompilerServices.Unsafe.IsNullRef``1(``0@)"/>.
+    /// </remarks>
+    [SuppressMessage("Documentation", "CA1200", Justification = "Not all targets can resolve the documented method reference.")]
+    public static ref TValue GetValueRefOrNullRef<TKey, TValue>(SegmentedDictionary<TKey, TValue> dictionary, TKey key)
+        where TKey : notnull
+        => ref SegmentedDictionary<TKey, TValue>.PrivateMarshal.FindValue(dictionary, key);
+
+    /// <summary>
+    /// Gets either a read-only ref to a <typeparamref name="TValue"/> in the <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/>
+    /// or a ref null if it does not exist in the <paramref name="dictionary"/>.
+    /// </summary>
+    /// <param name="dictionary">The dictionary to get the ref to <typeparamref name="TValue"/> from.</param>
+    /// <param name="key">The key used for lookup.</param>
+    /// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
+    /// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
+    /// <remarks>
+    /// The ref null can be detected using <see cref="M:System.Runtime.CompilerServices.Unsafe.IsNullRef``1(``0@)"/>.
+    /// </remarks>
+    [SuppressMessage("Documentation", "CA1200", Justification = "Not all targets can resolve the documented method reference.")]
+    public static ref readonly TValue GetValueRefOrNullRef<TKey, TValue>(ImmutableSegmentedDictionary<TKey, TValue> dictionary, TKey key)
+        where TKey : notnull
+        => ref ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.FindValue(dictionary, key);
+
+    /// <summary>
+    /// Gets either a ref to a <typeparamref name="TValue"/> in the <see cref="ImmutableSegmentedDictionary{TKey, TValue}.Builder"/>
+    /// or a ref null if it does not exist in the <paramref name="dictionary"/>.
+    /// </summary>
+    /// <param name="dictionary">The dictionary to get the ref to <typeparamref name="TValue"/> from.</param>
+    /// <param name="key">The key used for lookup.</param>
+    /// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
+    /// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
+    /// <remarks>
+    /// Items should not be added or removed from the <see cref="ImmutableSegmentedDictionary{TKey, TValue}.Builder"/>
+    /// while the ref <typeparamref name="TValue"/> is in use. The ref null can be detected using
+    /// <see cref="M:System.Runtime.CompilerServices.Unsafe.IsNullRef``1(``0@)"/>.
+    /// </remarks>
+    [SuppressMessage("Documentation", "CA1200", Justification = "Not all targets can resolve the documented method reference.")]
+    public static ref TValue GetValueRefOrNullRef<TKey, TValue>(ImmutableSegmentedDictionary<TKey, TValue>.Builder dictionary, TKey key)
+        where TKey : notnull
+        => ref ImmutableSegmentedDictionary<TKey, TValue>.Builder.PrivateMarshal.FindValue(dictionary, key);
+
+    /// <summary>
+    /// Gets an <see cref="ImmutableSegmentedList{T}"/> value wrapping the input <see cref="SegmentedList{T}"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the input segmented list.</typeparam>
+    /// <param name="list">The input segmented list to wrap in the returned <see cref="ImmutableSegmentedList{T}"/> value.</param>
+    /// <returns>An <see cref="ImmutableSegmentedList{T}"/> value wrapping <paramref name="list"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// When using this method, callers should take extra care to ensure that they're the sole owners of the input
+    /// list, and that it won't be modified once the returned <see cref="ImmutableSegmentedList{T}"/> value starts
+    /// being used. Doing so might cause undefined behavior in code paths which don't expect the contents of a given
+    /// <see cref="ImmutableSegmentedList{T}"/> values to change after its creation.
+    /// </para>
+    /// <para>
+    /// If <paramref name="list"/> is <see langword="null"/>, the returned <see cref="ImmutableSegmentedList{T}"/> value
+    /// will be uninitialized (i.e. its <see cref="ImmutableSegmentedList{T}.IsDefault"/> property will be
+    /// <see langword="true"/>).
+    /// </para>
+    /// </remarks>
+    public static ImmutableSegmentedList<T> AsImmutableSegmentedList<T>(SegmentedList<T>? list)
+        => ImmutableSegmentedList<T>.PrivateInterlocked.AsImmutableSegmentedList(list);
+
+    /// <summary>
+    /// Gets the underlying <see cref="SegmentedList{T}"/> for an input <see cref="ImmutableSegmentedList{T}"/> value.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the input <see cref="ImmutableSegmentedList{T}"/> value.</typeparam>
+    /// <param name="list">The input <see cref="ImmutableSegmentedList{T}"/> value to get the underlying <see cref="SegmentedList{T}"/> from.</param>
+    /// <returns>The underlying <see cref="SegmentedList{T}"/> for <paramref name="list"/>, if present; otherwise, <see langword="null"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// When using this method, callers should make sure to not pass the resulting underlying list to methods that
+    /// might mutate it. Doing so might cause undefined behavior in code paths using <paramref name="list"/> which
+    /// don't expect the contents of the <see cref="ImmutableSegmentedList{T}"/> value to change.
+    /// </para>
+    /// <para>
+    /// If <paramref name="list"/> is uninitialized (i.e. its <see cref="ImmutableSegmentedList{T}.IsDefault"/> property is
+    /// <see langword="true"/>), the resulting <see cref="SegmentedList{T}"/> will be <see langword="null"/>.
+    /// </para>
+    /// </remarks>
+    public static SegmentedList<T>? AsSegmentedList<T>(ImmutableSegmentedList<T> list)
+        => ImmutableSegmentedList<T>.PrivateInterlocked.AsSegmentedList(list);
+
+    /// <summary>
+    /// Gets an <see cref="ImmutableSegmentedHashSet{T}"/> value wrapping the input <see cref="SegmentedHashSet{T}"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the input segmented hash set.</typeparam>
+    /// <param name="set">The input segmented hash set to wrap in the returned <see cref="ImmutableSegmentedHashSet{T}"/> value.</param>
+    /// <returns>An <see cref="ImmutableSegmentedHashSet{T}"/> value wrapping <paramref name="set"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// When using this method, callers should take extra care to ensure that they're the sole owners of the input
+    /// set, and that it won't be modified once the returned <see cref="ImmutableSegmentedHashSet{T}"/> value starts
+    /// being used. Doing so might cause undefined behavior in code paths which don't expect the contents of a given
+    /// <see cref="ImmutableSegmentedHashSet{T}"/> values to change after its creation.
+    /// </para>
+    /// <para>
+    /// If <paramref name="set"/> is <see langword="null"/>, the returned <see cref="ImmutableSegmentedHashSet{T}"/>
+    /// value will be uninitialized (i.e. its <see cref="ImmutableSegmentedHashSet{T}.IsDefault"/> property will be
+    /// <see langword="true"/>).
+    /// </para>
+    /// </remarks>
+    public static ImmutableSegmentedHashSet<T> AsImmutableSegmentedHashSet<T>(SegmentedHashSet<T>? set)
+        => ImmutableSegmentedHashSet<T>.PrivateInterlocked.AsImmutableSegmentedHashSet(set);
+
+    /// <summary>
+    /// Gets the underlying <see cref="SegmentedHashSet{T}"/> for an input <see cref="ImmutableSegmentedHashSet{T}"/> value.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the input <see cref="ImmutableSegmentedHashSet{T}"/> value.</typeparam>
+    /// <param name="set">The input <see cref="ImmutableSegmentedHashSet{T}"/> value to get the underlying <see cref="SegmentedHashSet{T}"/> from.</param>
+    /// <returns>The underlying <see cref="SegmentedHashSet{T}"/> for <paramref name="set"/>, if present; otherwise, <see langword="null"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// When using this method, callers should make sure to not pass the resulting underlying hash set to methods that
+    /// might mutate it. Doing so might cause undefined behavior in code paths using <paramref name="set"/> which
+    /// don't expect the contents of the <see cref="ImmutableSegmentedHashSet{T}"/> value to change.
+    /// </para>
+    /// <para>
+    /// If <paramref name="set"/> is uninitialized (i.e. its <see cref="ImmutableSegmentedHashSet{T}.IsDefault"/>
+    /// property is <see langword="true"/>), the resulting <see cref="SegmentedHashSet{T}"/> will be <see langword="null"/>.
+    /// </para>
+    /// </remarks>
+    public static SegmentedHashSet<T>? AsSegmentedHashSet<T>(ImmutableSegmentedHashSet<T> set)
+        => ImmutableSegmentedHashSet<T>.PrivateInterlocked.AsSegmentedHashSet(set);
+
+    /// <summary>
+    /// Gets an <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value wrapping the input <see cref="SegmentedDictionary{TKey, TValue}"/>.
+    /// </summary>
+    /// <typeparam name="TKey">The type of keys in the input segmented dictionary.</typeparam>
+    /// <typeparam name="TValue">The type of values in the input segmented dictionary.</typeparam>
+    /// <param name="dictionary">The input segmented dictionary to wrap in the returned <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value.</param>
+    /// <returns>An <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value wrapping <paramref name="dictionary"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// When using this method, callers should take extra care to ensure that they're the sole owners of the input
+    /// dictionary, and that it won't be modified once the returned <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/>
+    /// value starts being used. Doing so might cause undefined behavior in code paths which don't expect the contents
+    /// of a given <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> values to change after its creation.
+    /// </para>
+    /// <para>
+    /// If <paramref name="dictionary"/> is <see langword="null"/>, the returned <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/>
+    /// value will be uninitialized (i.e. its <see cref="ImmutableSegmentedDictionary{TKey, TValue}.IsDefault"/>
+    /// property will be <see langword="true"/>).
+    /// </para>
+    /// </remarks>
+    public static ImmutableSegmentedDictionary<TKey, TValue> AsImmutableSegmentedDictionary<TKey, TValue>(SegmentedDictionary<TKey, TValue>? dictionary)
+        where TKey : notnull
+        => ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.AsImmutableSegmentedDictionary(dictionary);
+
+    /// <summary>
+    /// Gets the underlying <see cref="SegmentedDictionary{TKey, TValue}"/> for an input <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value.
+    /// </summary>
+    /// <typeparam name="TKey">The type of keys in the input <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value.</typeparam>
+    /// <typeparam name="TValue">The type of values in the input <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value.</typeparam>
+    /// <param name="dictionary">The input <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value to get the underlying <see cref="SegmentedDictionary{TKey, TValue}"/> from.</param>
+    /// <returns>The underlying <see cref="SegmentedDictionary{TKey, TValue}"/> for <paramref name="dictionary"/>, if present; otherwise, <see langword="null"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// When using this method, callers should make sure to not pass the resulting underlying dictionary to methods that
+    /// might mutate it. Doing so might cause undefined behavior in code paths using <paramref name="dictionary"/> which
+    /// don't expect the contents of the <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value to change.
+    /// </para>
+    /// <para>
+    /// If <paramref name="dictionary"/> is uninitialized (i.e. its <see cref="ImmutableSegmentedDictionary{TKey, TValue}.IsDefault"/>
+    /// property is <see langword="true"/>), the resulting <see cref="SegmentedDictionary{TKey, TValue}"/> will be <see langword="null"/>.
+    /// </para>
+    /// </remarks>
+    public static SegmentedDictionary<TKey, TValue>? AsSegmentedDictionary<TKey, TValue>(ImmutableSegmentedDictionary<TKey, TValue> dictionary)
+        where TKey : notnull
+        => ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.AsSegmentedDictionary(dictionary);
+}
diff --git a/src/Dependencies/Collections/SegmentedDictionary`2+PrivateMarshal.cs b/src/Dependencies/Collections/SegmentedDictionary`2+PrivateMarshal.cs
new file mode 100644
index 0000000000000..b008a411e6a1d
--- /dev/null
+++ b/src/Dependencies/Collections/SegmentedDictionary`2+PrivateMarshal.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.Collections;
+
+internal sealed partial class SegmentedDictionary<TKey, TValue>
+{
+    /// <summary>
+    /// Private helper class for use only by <see cref="SegmentedCollectionsMarshal"/>.
+    /// </summary>
+    internal static class PrivateMarshal
+    {
+        /// <inheritdoc cref="SegmentedCollectionsMarshal.GetValueRefOrNullRef{TKey, TValue}(SegmentedDictionary{TKey, TValue}, TKey)"/>
+        public static ref TValue FindValue(SegmentedDictionary<TKey, TValue> dictionary, TKey key)
+            => ref dictionary.FindValue(key);
+    }
+}
diff --git a/src/Dependencies/Collections/SegmentedDictionary`2.cs b/src/Dependencies/Collections/SegmentedDictionary`2.cs
index 5540d72ff8301..225530726cc93 100644
--- a/src/Dependencies/Collections/SegmentedDictionary`2.cs
+++ b/src/Dependencies/Collections/SegmentedDictionary`2.cs
@@ -29,7 +29,7 @@ namespace Microsoft.CodeAnalysis.Collections
     /// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
     [DebuggerTypeProxy(typeof(IDictionaryDebugView<,>))]
     [DebuggerDisplay("Count = {Count}")]
-    internal sealed class SegmentedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>
+    internal sealed partial class SegmentedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>
         where TKey : notnull
     {
         private const bool SupportsComparerDevirtualization

From aed9cf45b722f96b193d628bc5ebbf7fe4bd6b97 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 5 Mar 2024 10:22:43 -0600
Subject: [PATCH 004/170] Provide SegmentedCollectionsMarshal.AsSegments for
 SegmentedArray<T>

---
 .../Collections/SegmentedArrayTests.cs         | 10 +++++-----
 ...icrosoft.CodeAnalysis.Collections.projitems |  1 +
 src/Dependencies/Collections/SegmentedArray.cs | 12 ++++++------
 .../SegmentedArray`1+PrivateMarshal.cs         | 18 ++++++++++++++++++
 .../Collections/SegmentedArray`1.cs            | 16 ++--------------
 .../Collections/SegmentedCollectionsMarshal.cs | 10 ++++++++++
 .../Collections/SegmentedList`1.cs             |  2 +-
 7 files changed, 43 insertions(+), 26 deletions(-)
 create mode 100644 src/Dependencies/Collections/SegmentedArray`1+PrivateMarshal.cs

diff --git a/src/Compilers/Core/CodeAnalysisTest/Collections/SegmentedArrayTests.cs b/src/Compilers/Core/CodeAnalysisTest/Collections/SegmentedArrayTests.cs
index 6a24b3fa32c99..599103ee1950e 100644
--- a/src/Compilers/Core/CodeAnalysisTest/Collections/SegmentedArrayTests.cs
+++ b/src/Compilers/Core/CodeAnalysisTest/Collections/SegmentedArrayTests.cs
@@ -41,7 +41,7 @@ private static void ResetToSequence(SegmentedArray<IntPtr> array)
         public void TestDefaultInstance()
         {
             var data = default(SegmentedArray<IntPtr>);
-            Assert.Null(data.GetTestAccessor().Items);
+            Assert.Null(SegmentedCollectionsMarshal.AsSegments(data));
 
             Assert.True(data.IsFixedSize);
             Assert.True(data.IsReadOnly);
@@ -96,7 +96,7 @@ public void TestConstructor1()
             Assert.Throws<ArgumentOutOfRangeException>("length", () => new SegmentedArray<byte>(-1));
 
             Assert.Empty(new SegmentedArray<byte>(0));
-            Assert.Same(Array.Empty<byte[]>(), new SegmentedArray<byte>(0).GetTestAccessor().Items);
+            Assert.Same(Array.Empty<byte[]>(), SegmentedCollectionsMarshal.AsSegments(new SegmentedArray<byte>(0)));
         }
 
         [Theory]
@@ -106,7 +106,7 @@ public void TestConstructor2(int length)
             var data = new SegmentedArray<IntPtr>(length);
             Assert.Equal(length, data.Length);
 
-            var items = data.GetTestAccessor().Items;
+            var items = SegmentedCollectionsMarshal.AsSegments(data);
             Assert.Equal(length, items.Sum(item => item.Length));
 
             for (var i = 0; i < items.Length - 1; i++)
@@ -126,7 +126,7 @@ public void TestBasicProperties(int length)
             Assert.True(data.IsReadOnly);
             Assert.False(data.IsSynchronized);
             Assert.Equal(length, data.Length);
-            Assert.Same(data.GetTestAccessor().Items, data.SyncRoot);
+            Assert.Same(SegmentedCollectionsMarshal.AsSegments(data), data.SyncRoot);
 
             Assert.Equal(length, ((ICollection)data).Count);
             Assert.Equal(length, ((ICollection<IntPtr>)data).Count);
@@ -192,7 +192,7 @@ public void TestIndexer(int length)
         public void TestIterateLargeArray()
         {
             var data = new SegmentedArray<Guid>(1000000);
-            Assert.True(data.GetTestAccessor().Items.Length > 10);
+            Assert.True(SegmentedCollectionsMarshal.AsSegments(data).Length > 10);
 
             for (var i = 0; i < data.Length; i++)
             {
diff --git a/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems b/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
index a8a099456ae40..0f2d1b85bb55b 100644
--- a/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
+++ b/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
@@ -53,6 +53,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)RoslynEnumerable.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)RoslynImmutableInterlocked.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedArray.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)SegmentedArray`1+PrivateMarshal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedArray`1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedCollectionsMarshal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)SegmentedDictionary`2+PrivateMarshal.cs" />
diff --git a/src/Dependencies/Collections/SegmentedArray.cs b/src/Dependencies/Collections/SegmentedArray.cs
index 8644ebbce1415..b63ad2234be62 100644
--- a/src/Dependencies/Collections/SegmentedArray.cs
+++ b/src/Dependencies/Collections/SegmentedArray.cs
@@ -84,7 +84,7 @@ public static void Copy<T>(SegmentedArray<T> sourceArray, int sourceIndex, Segme
             if (length == 0)
                 return;
 
-            if (sourceArray.SyncRoot == destinationArray.SyncRoot
+            if (SegmentedCollectionsMarshal.AsSegments(sourceArray) == SegmentedCollectionsMarshal.AsSegments(destinationArray)
                 && sourceIndex + length > destinationIndex)
             {
                 // We are copying in the same array with overlap
@@ -439,7 +439,7 @@ public AlignedSegmentEnumerable(SegmentedArray<T> first, int firstOffset, Segmen
             }
 
             public AlignedSegmentEnumerator<T> GetEnumerator()
-                => new((T[][])_first.SyncRoot, _firstOffset, (T[][])_second.SyncRoot, _secondOffset, _length);
+                => new(SegmentedCollectionsMarshal.AsSegments(_first), _firstOffset, SegmentedCollectionsMarshal.AsSegments(_second), _secondOffset, _length);
         }
 
         private struct AlignedSegmentEnumerator<T>
@@ -525,7 +525,7 @@ public UnalignedSegmentEnumerable(SegmentedArray<T> first, int firstOffset, Segm
             }
 
             public UnalignedSegmentEnumerator<T> GetEnumerator()
-                => new((T[][])_first.SyncRoot, _firstOffset, (T[][])_second.SyncRoot, _secondOffset, _length);
+                => new(SegmentedCollectionsMarshal.AsSegments(_first), _firstOffset, SegmentedCollectionsMarshal.AsSegments(_second), _secondOffset, _length);
 
             public ReverseEnumerable Reverse()
                 => new(this);
@@ -540,7 +540,7 @@ public ReverseEnumerable(UnalignedSegmentEnumerable<T> enumerable)
                 }
 
                 public UnalignedSegmentEnumerator<T>.Reverse GetEnumerator()
-                => new((T[][])_enumerable._first.SyncRoot, _enumerable._firstOffset, (T[][])_enumerable._second.SyncRoot, _enumerable._secondOffset, _enumerable._length);
+                => new(SegmentedCollectionsMarshal.AsSegments(_enumerable._first), _enumerable._firstOffset, SegmentedCollectionsMarshal.AsSegments(_enumerable._second), _enumerable._secondOffset, _enumerable._length);
 
                 public UnalignedSegmentEnumerable<T> Reverse()
                     => _enumerable;
@@ -669,7 +669,7 @@ public SegmentEnumerable(SegmentedArray<T> array, int offset, int length)
             }
 
             public SegmentEnumerator<T> GetEnumerator()
-                => new((T[][])_array.SyncRoot, _offset, _length);
+                => new(SegmentedCollectionsMarshal.AsSegments(_array), _offset, _length);
 
             public ReverseEnumerable Reverse()
                 => new(this);
@@ -684,7 +684,7 @@ public ReverseEnumerable(SegmentEnumerable<T> enumerable)
                 }
 
                 public SegmentEnumerator<T>.Reverse GetEnumerator()
-                    => new((T[][])_enumerable._array.SyncRoot, _enumerable._offset, _enumerable._length);
+                    => new(SegmentedCollectionsMarshal.AsSegments(_enumerable._array), _enumerable._offset, _enumerable._length);
 
                 public SegmentEnumerable<T> Reverse()
                     => _enumerable;
diff --git a/src/Dependencies/Collections/SegmentedArray`1+PrivateMarshal.cs b/src/Dependencies/Collections/SegmentedArray`1+PrivateMarshal.cs
new file mode 100644
index 0000000000000..d4ad3359886dc
--- /dev/null
+++ b/src/Dependencies/Collections/SegmentedArray`1+PrivateMarshal.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.CodeAnalysis.Collections;
+
+internal readonly partial struct SegmentedArray<T>
+{
+    /// <summary>
+    /// Private helper class for use only by <see cref="SegmentedCollectionsMarshal"/>.
+    /// </summary>
+    internal static class PrivateMarshal
+    {
+        /// <inheritdoc cref="SegmentedCollectionsMarshal.AsSegments{T}(SegmentedArray{T})"/>
+        public static T[][] AsSegments(SegmentedArray<T> array)
+            => array._items;
+    }
+}
diff --git a/src/Dependencies/Collections/SegmentedArray`1.cs b/src/Dependencies/Collections/SegmentedArray`1.cs
index 9bb6c32dc5384..ac7f5d9801ce2 100644
--- a/src/Dependencies/Collections/SegmentedArray`1.cs
+++ b/src/Dependencies/Collections/SegmentedArray`1.cs
@@ -17,7 +17,7 @@ namespace Microsoft.CodeAnalysis.Collections
     /// collection uses segmented arrays to avoid placing objects on the Large Object Heap.
     /// </summary>
     /// <typeparam name="T">The type of elements stored in the array.</typeparam>
-    internal readonly struct SegmentedArray<T> : ICloneable, IList, IStructuralComparable, IStructuralEquatable, IList<T>, IReadOnlyList<T>, IEquatable<SegmentedArray<T>>
+    internal readonly partial struct SegmentedArray<T> : ICloneable, IList, IStructuralComparable, IStructuralEquatable, IList<T>, IReadOnlyList<T>, IEquatable<SegmentedArray<T>>
     {
         /// <summary>
         /// The number of elements in each page of the segmented array of type <typeparamref name="T"/>.
@@ -365,9 +365,6 @@ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
             return ret;
         }
 
-        internal TestAccessor GetTestAccessor()
-            => new(this);
-
         public struct Enumerator : IEnumerator<T>
         {
             private readonly T[][] _items;
@@ -419,18 +416,9 @@ public void Reset()
             }
         }
 
-        internal readonly struct TestAccessor
+        internal static class TestAccessor
         {
-            private readonly SegmentedArray<T> _array;
-
-            public TestAccessor(SegmentedArray<T> array)
-            {
-                _array = array;
-            }
-
             public static int SegmentSize => SegmentedArray<T>.SegmentSize;
-
-            public T[][] Items => _array._items;
         }
     }
 }
diff --git a/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs b/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
index e95a4463196aa..86976bea7fb78 100644
--- a/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
+++ b/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
@@ -12,6 +12,16 @@ namespace Microsoft.CodeAnalysis.Collections;
 /// </summary>
 internal static class SegmentedCollectionsMarshal
 {
+    /// <summary>
+    /// Gets the backing storage array for a <see cref="SegmentedArray{T}"/>.
+    /// </summary>
+    /// <typeparam name="T">The type of elements stored in the array.</typeparam>
+    /// <param name="array">The segmented array.</param>
+    /// <returns>The backing storage array for the segmented array. Note that replacing segments within the returned
+    /// value will invalidate the <see cref="SegmentedArray{T}"/> data structure.</returns>
+    public static T[][] AsSegments<T>(SegmentedArray<T> array)
+        => SegmentedArray<T>.PrivateMarshal.AsSegments(array);
+
     /// <summary>
     /// Gets either a ref to a <typeparamref name="TValue"/> in the <see cref="SegmentedDictionary{TKey, TValue}"/> or a
     /// ref null if it does not exist in the <paramref name="dictionary"/>.
diff --git a/src/Dependencies/Collections/SegmentedList`1.cs b/src/Dependencies/Collections/SegmentedList`1.cs
index 8b14f8d8e5566..dd36dc375bf26 100644
--- a/src/Dependencies/Collections/SegmentedList`1.cs
+++ b/src/Dependencies/Collections/SegmentedList`1.cs
@@ -91,7 +91,7 @@ public SegmentedList(IEnumerable<T> collection)
                 else
                 {
                     _items = new SegmentedArray<T>(count);
-                    if ((T[][])_items.SyncRoot is { Length: 1 } segments)
+                    if (SegmentedCollectionsMarshal.AsSegments(_items) is { Length: 1 } segments)
                     {
                         c.CopyTo(segments[0], 0);
                         _size = count;

From 2cf6e47df0843d3986c96c1e954d716d43e3e2d2 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Tue, 5 Mar 2024 10:28:41 -0600
Subject: [PATCH 005/170] Rename PrivateInterlocked to PrivateMarshal for
 consistency

---
 ...leSegmentedDictionary`2+PrivateMarshal.cs} |  2 +-
 ...tableSegmentedHashSet`1+PrivateMarshal.cs} |  2 +-
 ...mmutableSegmentedList`1+PrivateMarshal.cs} |  2 +-
 ...crosoft.CodeAnalysis.Collections.projitems |  6 +--
 .../Collections/RoslynImmutableInterlocked.cs | 40 +++++++++----------
 .../SegmentedCollectionsMarshal.cs            | 14 +++----
 6 files changed, 33 insertions(+), 33 deletions(-)
 rename src/Dependencies/Collections/{ImmutableSegmentedDictionary`2+PrivateInterlocked.cs => ImmutableSegmentedDictionary`2+PrivateMarshal.cs} (98%)
 rename src/Dependencies/Collections/{ImmutableSegmentedHashSet`1+PrivateInterlocked.cs => ImmutableSegmentedHashSet`1+PrivateMarshal.cs} (98%)
 rename src/Dependencies/Collections/{ImmutableSegmentedList`1+PrivateInterlocked.cs => ImmutableSegmentedList`1+PrivateMarshal.cs} (97%)

diff --git a/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateInterlocked.cs b/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateMarshal.cs
similarity index 98%
rename from src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateInterlocked.cs
rename to src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateMarshal.cs
index b45f1b375cf11..c50fc90148c7b 100644
--- a/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateInterlocked.cs
+++ b/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+PrivateMarshal.cs
@@ -13,7 +13,7 @@ internal readonly partial struct ImmutableSegmentedDictionary<TKey, TValue>
         /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/> and
         /// <see cref="SegmentedCollectionsMarshal"/>.
         /// </summary>
-        internal static class PrivateInterlocked
+        internal static class PrivateMarshal
         {
             internal static ImmutableSegmentedDictionary<TKey, TValue> VolatileRead(in ImmutableSegmentedDictionary<TKey, TValue> location)
             {
diff --git a/src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateInterlocked.cs b/src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateMarshal.cs
similarity index 98%
rename from src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateInterlocked.cs
rename to src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateMarshal.cs
index dcb0acb0e3499..cb8ed1656690e 100644
--- a/src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateInterlocked.cs
+++ b/src/Dependencies/Collections/ImmutableSegmentedHashSet`1+PrivateMarshal.cs
@@ -13,7 +13,7 @@ internal readonly partial struct ImmutableSegmentedHashSet<T>
         /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/> and
         /// <see cref="SegmentedCollectionsMarshal"/>.
         /// </summary>
-        internal static class PrivateInterlocked
+        internal static class PrivateMarshal
         {
             internal static ImmutableSegmentedHashSet<T> VolatileRead(in ImmutableSegmentedHashSet<T> location)
             {
diff --git a/src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateInterlocked.cs b/src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateMarshal.cs
similarity index 97%
rename from src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateInterlocked.cs
rename to src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateMarshal.cs
index 871ac2535fbf1..cf945b2144ce6 100644
--- a/src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateInterlocked.cs
+++ b/src/Dependencies/Collections/ImmutableSegmentedList`1+PrivateMarshal.cs
@@ -13,7 +13,7 @@ internal partial struct ImmutableSegmentedList<T>
         /// Private helper class for use only by <see cref="RoslynImmutableInterlocked"/> and
         /// <see cref="SegmentedCollectionsMarshal"/>.
         /// </summary>
-        internal static class PrivateInterlocked
+        internal static class PrivateMarshal
         {
             internal static ImmutableSegmentedList<T> VolatileRead(in ImmutableSegmentedList<T> location)
             {
diff --git a/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems b/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
index 0f2d1b85bb55b..793bff9426dc8 100644
--- a/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
+++ b/src/Dependencies/Collections/Microsoft.CodeAnalysis.Collections.projitems
@@ -18,20 +18,20 @@
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+Enumerator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+KeyCollection+Enumerator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+KeyCollection.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+PrivateInterlocked.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+PrivateMarshal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+ValueCollection+Enumerator.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2+ValueCollection.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedDictionary`2.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedHashSet.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedHashSet`1+Builder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedHashSet`1+Enumerator.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedHashSet`1+PrivateInterlocked.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedHashSet`1+PrivateMarshal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedHashSet`1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedList.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedListExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedList`1+Builder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedList`1+Enumerator.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedList`1+PrivateInterlocked.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedList`1+PrivateMarshal.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedList`1+ValueBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ImmutableSegmentedList`1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Internal\ArraySortHelper.cs" />
diff --git a/src/Dependencies/Collections/RoslynImmutableInterlocked.cs b/src/Dependencies/Collections/RoslynImmutableInterlocked.cs
index 03176df0b832b..a96084a0bab16 100644
--- a/src/Dependencies/Collections/RoslynImmutableInterlocked.cs
+++ b/src/Dependencies/Collections/RoslynImmutableInterlocked.cs
@@ -32,7 +32,7 @@ public static bool Update<T>(ref ImmutableSegmentedList<T> location, Func<Immuta
             if (transformer is null)
                 throw new ArgumentNullException(nameof(transformer));
 
-            var oldValue = ImmutableSegmentedList<T>.PrivateInterlocked.VolatileRead(in location);
+            var oldValue = ImmutableSegmentedList<T>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 var newValue = transformer(oldValue);
@@ -73,7 +73,7 @@ public static bool Update<T, TArg>(ref ImmutableSegmentedList<T> location, Func<
             if (transformer is null)
                 throw new ArgumentNullException(nameof(transformer));
 
-            var oldValue = ImmutableSegmentedList<T>.PrivateInterlocked.VolatileRead(in location);
+            var oldValue = ImmutableSegmentedList<T>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 var newValue = transformer(oldValue, transformerArgument);
@@ -101,7 +101,7 @@ public static bool Update<T, TArg>(ref ImmutableSegmentedList<T> location, Func<
         /// <returns>The prior value at the specified <paramref name="location"/>.</returns>
         public static ImmutableSegmentedList<T> InterlockedExchange<T>(ref ImmutableSegmentedList<T> location, ImmutableSegmentedList<T> value)
         {
-            return ImmutableSegmentedList<T>.PrivateInterlocked.InterlockedExchange(ref location, value);
+            return ImmutableSegmentedList<T>.PrivateMarshal.InterlockedExchange(ref location, value);
         }
 
         /// <summary>
@@ -115,7 +115,7 @@ public static ImmutableSegmentedList<T> InterlockedExchange<T>(ref ImmutableSegm
         /// <returns>The prior value at the specified <paramref name="location"/>.</returns>
         public static ImmutableSegmentedList<T> InterlockedCompareExchange<T>(ref ImmutableSegmentedList<T> location, ImmutableSegmentedList<T> value, ImmutableSegmentedList<T> comparand)
         {
-            return ImmutableSegmentedList<T>.PrivateInterlocked.InterlockedCompareExchange(ref location, value, comparand);
+            return ImmutableSegmentedList<T>.PrivateMarshal.InterlockedCompareExchange(ref location, value, comparand);
         }
 
         /// <summary>
@@ -153,7 +153,7 @@ public static bool Update<T>(ref ImmutableSegmentedHashSet<T> location, Func<Imm
             if (transformer is null)
                 throw new ArgumentNullException(nameof(transformer));
 
-            var oldValue = ImmutableSegmentedHashSet<T>.PrivateInterlocked.VolatileRead(in location);
+            var oldValue = ImmutableSegmentedHashSet<T>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 var newValue = transformer(oldValue);
@@ -194,7 +194,7 @@ public static bool Update<T, TArg>(ref ImmutableSegmentedHashSet<T> location, Fu
             if (transformer is null)
                 throw new ArgumentNullException(nameof(transformer));
 
-            var oldValue = ImmutableSegmentedHashSet<T>.PrivateInterlocked.VolatileRead(in location);
+            var oldValue = ImmutableSegmentedHashSet<T>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 var newValue = transformer(oldValue, transformerArgument);
@@ -222,7 +222,7 @@ public static bool Update<T, TArg>(ref ImmutableSegmentedHashSet<T> location, Fu
         /// <returns>The prior value at the specified <paramref name="location"/>.</returns>
         public static ImmutableSegmentedHashSet<T> InterlockedExchange<T>(ref ImmutableSegmentedHashSet<T> location, ImmutableSegmentedHashSet<T> value)
         {
-            return ImmutableSegmentedHashSet<T>.PrivateInterlocked.InterlockedExchange(ref location, value);
+            return ImmutableSegmentedHashSet<T>.PrivateMarshal.InterlockedExchange(ref location, value);
         }
 
         /// <summary>
@@ -236,7 +236,7 @@ public static ImmutableSegmentedHashSet<T> InterlockedExchange<T>(ref ImmutableS
         /// <returns>The prior value at the specified <paramref name="location"/>.</returns>
         public static ImmutableSegmentedHashSet<T> InterlockedCompareExchange<T>(ref ImmutableSegmentedHashSet<T> location, ImmutableSegmentedHashSet<T> value, ImmutableSegmentedHashSet<T> comparand)
         {
-            return ImmutableSegmentedHashSet<T>.PrivateInterlocked.InterlockedCompareExchange(ref location, value, comparand);
+            return ImmutableSegmentedHashSet<T>.PrivateMarshal.InterlockedCompareExchange(ref location, value, comparand);
         }
 
         /// <summary>
@@ -276,7 +276,7 @@ public static bool Update<TKey, TValue>(ref ImmutableSegmentedDictionary<TKey, T
             if (transformer is null)
                 throw new ArgumentNullException(nameof(transformer));
 
-            var oldValue = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var oldValue = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 var newValue = transformer(oldValue);
@@ -319,7 +319,7 @@ public static bool Update<TKey, TValue, TArg>(ref ImmutableSegmentedDictionary<T
             if (transformer is null)
                 throw new ArgumentNullException(nameof(transformer));
 
-            var oldValue = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var oldValue = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 var newValue = transformer(oldValue, transformerArgument);
@@ -349,7 +349,7 @@ public static bool Update<TKey, TValue, TArg>(ref ImmutableSegmentedDictionary<T
         public static ImmutableSegmentedDictionary<TKey, TValue> InterlockedExchange<TKey, TValue>(ref ImmutableSegmentedDictionary<TKey, TValue> location, ImmutableSegmentedDictionary<TKey, TValue> value)
             where TKey : notnull
         {
-            return ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.InterlockedExchange(ref location, value);
+            return ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.InterlockedExchange(ref location, value);
         }
 
         /// <summary>
@@ -365,7 +365,7 @@ public static ImmutableSegmentedDictionary<TKey, TValue> InterlockedExchange<TKe
         public static ImmutableSegmentedDictionary<TKey, TValue> InterlockedCompareExchange<TKey, TValue>(ref ImmutableSegmentedDictionary<TKey, TValue> location, ImmutableSegmentedDictionary<TKey, TValue> value, ImmutableSegmentedDictionary<TKey, TValue> comparand)
             where TKey : notnull
         {
-            return ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.InterlockedCompareExchange(ref location, value, comparand);
+            return ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.InterlockedCompareExchange(ref location, value, comparand);
         }
 
         /// <summary>
@@ -391,7 +391,7 @@ public static TValue GetOrAdd<TKey, TValue, TArg>(ref ImmutableSegmentedDictiona
             if (valueFactory is null)
                 throw new ArgumentNullException(nameof(valueFactory));
 
-            var map = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var map = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             if (map.IsDefault)
                 throw new ArgumentNullException(nameof(location));
 
@@ -411,7 +411,7 @@ public static TValue GetOrAdd<TKey, TValue>(ref ImmutableSegmentedDictionary<TKe
             if (valueFactory is null)
                 throw new ArgumentNullException(nameof(valueFactory));
 
-            var map = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var map = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             if (map.IsDefault)
                 throw new ArgumentNullException(nameof(location));
 
@@ -428,7 +428,7 @@ public static TValue GetOrAdd<TKey, TValue>(ref ImmutableSegmentedDictionary<TKe
         public static TValue GetOrAdd<TKey, TValue>(ref ImmutableSegmentedDictionary<TKey, TValue> location, TKey key, TValue value)
             where TKey : notnull
         {
-            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 if (priorCollection.IsDefault)
@@ -462,7 +462,7 @@ public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableSegmentedDictionary<
                 throw new ArgumentNullException(nameof(updateValueFactory));
 
             TValue newValue;
-            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 if (priorCollection.IsDefault)
@@ -498,7 +498,7 @@ public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableSegmentedDictionary<
                 throw new ArgumentNullException(nameof(updateValueFactory));
 
             TValue newValue;
-            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 if (priorCollection.IsDefault)
@@ -530,7 +530,7 @@ public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableSegmentedDictionary<
         public static bool TryAdd<TKey, TValue>(ref ImmutableSegmentedDictionary<TKey, TValue> location, TKey key, TValue value)
             where TKey : notnull
         {
-            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 if (priorCollection.IsDefault)
@@ -557,7 +557,7 @@ public static bool TryUpdate<TKey, TValue>(ref ImmutableSegmentedDictionary<TKey
             where TKey : notnull
         {
             var valueComparer = EqualityComparer<TValue>.Default;
-            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 if (priorCollection.IsDefault)
@@ -584,7 +584,7 @@ public static bool TryUpdate<TKey, TValue>(ref ImmutableSegmentedDictionary<TKey
         public static bool TryRemove<TKey, TValue>(ref ImmutableSegmentedDictionary<TKey, TValue> location, TKey key, [MaybeNullWhen(false)] out TValue value)
             where TKey : notnull
         {
-            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.VolatileRead(in location);
+            var priorCollection = ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.VolatileRead(in location);
             while (true)
             {
                 if (priorCollection.IsDefault)
diff --git a/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs b/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
index 86976bea7fb78..cb4c90b3f8c53 100644
--- a/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
+++ b/src/Dependencies/Collections/SegmentedCollectionsMarshal.cs
@@ -53,7 +53,7 @@ public static ref TValue GetValueRefOrNullRef<TKey, TValue>(SegmentedDictionary<
     [SuppressMessage("Documentation", "CA1200", Justification = "Not all targets can resolve the documented method reference.")]
     public static ref readonly TValue GetValueRefOrNullRef<TKey, TValue>(ImmutableSegmentedDictionary<TKey, TValue> dictionary, TKey key)
         where TKey : notnull
-        => ref ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.FindValue(dictionary, key);
+        => ref ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.FindValue(dictionary, key);
 
     /// <summary>
     /// Gets either a ref to a <typeparamref name="TValue"/> in the <see cref="ImmutableSegmentedDictionary{TKey, TValue}.Builder"/>
@@ -93,7 +93,7 @@ public static ref TValue GetValueRefOrNullRef<TKey, TValue>(ImmutableSegmentedDi
     /// </para>
     /// </remarks>
     public static ImmutableSegmentedList<T> AsImmutableSegmentedList<T>(SegmentedList<T>? list)
-        => ImmutableSegmentedList<T>.PrivateInterlocked.AsImmutableSegmentedList(list);
+        => ImmutableSegmentedList<T>.PrivateMarshal.AsImmutableSegmentedList(list);
 
     /// <summary>
     /// Gets the underlying <see cref="SegmentedList{T}"/> for an input <see cref="ImmutableSegmentedList{T}"/> value.
@@ -113,7 +113,7 @@ public static ImmutableSegmentedList<T> AsImmutableSegmentedList<T>(SegmentedLis
     /// </para>
     /// </remarks>
     public static SegmentedList<T>? AsSegmentedList<T>(ImmutableSegmentedList<T> list)
-        => ImmutableSegmentedList<T>.PrivateInterlocked.AsSegmentedList(list);
+        => ImmutableSegmentedList<T>.PrivateMarshal.AsSegmentedList(list);
 
     /// <summary>
     /// Gets an <see cref="ImmutableSegmentedHashSet{T}"/> value wrapping the input <see cref="SegmentedHashSet{T}"/>.
@@ -135,7 +135,7 @@ public static ImmutableSegmentedList<T> AsImmutableSegmentedList<T>(SegmentedLis
     /// </para>
     /// </remarks>
     public static ImmutableSegmentedHashSet<T> AsImmutableSegmentedHashSet<T>(SegmentedHashSet<T>? set)
-        => ImmutableSegmentedHashSet<T>.PrivateInterlocked.AsImmutableSegmentedHashSet(set);
+        => ImmutableSegmentedHashSet<T>.PrivateMarshal.AsImmutableSegmentedHashSet(set);
 
     /// <summary>
     /// Gets the underlying <see cref="SegmentedHashSet{T}"/> for an input <see cref="ImmutableSegmentedHashSet{T}"/> value.
@@ -155,7 +155,7 @@ public static ImmutableSegmentedHashSet<T> AsImmutableSegmentedHashSet<T>(Segmen
     /// </para>
     /// </remarks>
     public static SegmentedHashSet<T>? AsSegmentedHashSet<T>(ImmutableSegmentedHashSet<T> set)
-        => ImmutableSegmentedHashSet<T>.PrivateInterlocked.AsSegmentedHashSet(set);
+        => ImmutableSegmentedHashSet<T>.PrivateMarshal.AsSegmentedHashSet(set);
 
     /// <summary>
     /// Gets an <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value wrapping the input <see cref="SegmentedDictionary{TKey, TValue}"/>.
@@ -179,7 +179,7 @@ public static ImmutableSegmentedHashSet<T> AsImmutableSegmentedHashSet<T>(Segmen
     /// </remarks>
     public static ImmutableSegmentedDictionary<TKey, TValue> AsImmutableSegmentedDictionary<TKey, TValue>(SegmentedDictionary<TKey, TValue>? dictionary)
         where TKey : notnull
-        => ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.AsImmutableSegmentedDictionary(dictionary);
+        => ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.AsImmutableSegmentedDictionary(dictionary);
 
     /// <summary>
     /// Gets the underlying <see cref="SegmentedDictionary{TKey, TValue}"/> for an input <see cref="ImmutableSegmentedDictionary{TKey, TValue}"/> value.
@@ -201,5 +201,5 @@ public static ImmutableSegmentedDictionary<TKey, TValue> AsImmutableSegmentedDic
     /// </remarks>
     public static SegmentedDictionary<TKey, TValue>? AsSegmentedDictionary<TKey, TValue>(ImmutableSegmentedDictionary<TKey, TValue> dictionary)
         where TKey : notnull
-        => ImmutableSegmentedDictionary<TKey, TValue>.PrivateInterlocked.AsSegmentedDictionary(dictionary);
+        => ImmutableSegmentedDictionary<TKey, TValue>.PrivateMarshal.AsSegmentedDictionary(dictionary);
 }

From c910040ee8de47b3c981cdcfce0716079c0132b9 Mon Sep 17 00:00:00 2001
From: sdelarosbil <sdelarosbil@spiria.com>
Date: Wed, 6 Mar 2024 12:12:09 -0500
Subject: [PATCH 006/170] Add support for PrimaryConstructorBaseType to
 SpeculativeAnalyser

---
 .../UseCollectionExpressionForArrayTests.cs     | 17 +++++++++++++++++
 .../CSharp/Utilities/SpeculationAnalyzer.cs     |  7 ++++++-
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs b/src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs
index 2bb03152de101..2004bccfebaa5 100644
--- a/src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs
@@ -1107,6 +1107,23 @@ void X(int[] x) { }
         }.RunAsync();
     }
 
+    [Fact]
+    public async Task TestTargetTypedArgumentPrimaryConstructor1()
+    {
+        await new VerifyCS.Test
+        {
+            TestCode = """
+                       class C(int[] x);
+                       class C2() : C([|[|new|] int[]|] { 1, 2, 3 });
+                       """,
+            FixedCode = """
+                        class C(int[] x);
+                        class C2() : C([1, 2, 3]);
+                        """,
+            LanguageVersion = LanguageVersion.CSharp12,
+        }.RunAsync();
+    }
+
     [Fact]
     public async Task TestNotTargetTypedArgument2()
     {
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Utilities/SpeculationAnalyzer.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Utilities/SpeculationAnalyzer.cs
index 336f47418533b..de81fa58d62d6 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Utilities/SpeculationAnalyzer.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Utilities/SpeculationAnalyzer.cs
@@ -85,7 +85,8 @@ public static bool CanSpeculateOnNode(SyntaxNode node)
                           SyntaxKind.ThisConstructorInitializer or
                           SyntaxKind.BaseConstructorInitializer or
                           SyntaxKind.EqualsValueClause or
-                          SyntaxKind.ArrowExpressionClause;
+                          SyntaxKind.ArrowExpressionClause or
+                          SyntaxKind.PrimaryConstructorBaseType;
 
     protected override void ValidateSpeculativeSemanticModel(SemanticModel speculativeSemanticModel, SyntaxNode nodeToSpeculate)
     {
@@ -157,6 +158,10 @@ public static SemanticModel CreateSpeculativeSemanticModelForNode(SyntaxNode nod
             case SyntaxKind.ArrowExpressionClause:
                 semanticModel.TryGetSpeculativeSemanticModel(position, (ArrowExpressionClauseSyntax)nodeToSpeculate, out speculativeModel);
                 return speculativeModel;
+
+            case SyntaxKind.PrimaryConstructorBaseType:
+                semanticModel.TryGetSpeculativeSemanticModel(position, (PrimaryConstructorBaseTypeSyntax)nodeToSpeculate, out speculativeModel);
+                return speculativeModel;
         }
 
         // CONSIDER: Do we care about this case?

From 7564430984bad44d3483aa415dc52dc465bc80d7 Mon Sep 17 00:00:00 2001
From: Sam Harwell <Sam.Harwell@microsoft.com>
Date: Wed, 6 Mar 2024 10:11:18 -0600
Subject: [PATCH 007/170] Add tests for SegmentedCollectionsMarshal

---
 .../SegmentedCollectionsMarshalTests.cs       | 821 ++++++++++++++++++
 .../ImmutableSegmentedDictionary`2+Builder.cs |   9 +
 .../Collections/SegmentedList`1.cs            |   8 +
 3 files changed, 838 insertions(+)
 create mode 100644 src/Compilers/Core/CodeAnalysisTest/Collections/SegmentedCollectionsMarshalTests.cs

diff --git a/src/Compilers/Core/CodeAnalysisTest/Collections/SegmentedCollectionsMarshalTests.cs b/src/Compilers/Core/CodeAnalysisTest/Collections/SegmentedCollectionsMarshalTests.cs
new file mode 100644
index 0000000000000..9ce6bde89aa5c
--- /dev/null
+++ b/src/Compilers/Core/CodeAnalysisTest/Collections/SegmentedCollectionsMarshalTests.cs
@@ -0,0 +1,821 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using Microsoft.CodeAnalysis.Collections;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.UnitTests.Collections;
+
+public class SegmentedCollectionsMarshalTests
+{
+    [Fact]
+    public void SegmentedDictionary_GetValueRefOrNullRefValueType()
+    {
+        var dict = new SegmentedDictionary<int, Struct>
+        {
+            {  1, default },
+            {  2, default },
+        };
+
+        Assert.Equal(2, dict.Count);
+
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        Struct itemVal = dict[1];
+        itemVal.Value = 1;
+        itemVal.Property = 2;
+
+        // Does not change values in dictionary
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Value = 3;
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Property = 4;
+
+        Assert.Equal(3, dict[1].Value);
+        Assert.Equal(4, dict[1].Property);
+
+        ref Struct itemRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 2);
+
+        Assert.Equal(0, itemRef.Value);
+        Assert.Equal(0, itemRef.Property);
+
+        itemRef.Value = 5;
+        itemRef.Property = 6;
+
+        Assert.Equal(5, itemRef.Value);
+        Assert.Equal(6, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        itemRef = new Struct() { Value = 7, Property = 8 };
+
+        Assert.Equal(7, itemRef.Value);
+        Assert.Equal(8, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        // Check for null refs
+
+        Assert.True(Unsafe.IsNullRef(ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3)));
+        Assert.Throws<NullReferenceException>(() => SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3).Value = 9);
+
+        Assert.Equal(2, dict.Count);
+    }
+
+    [Fact]
+    public void SegmentedDictionary_GetValueRefOrNullRefClass()
+    {
+        var dict = new SegmentedDictionary<int, IntAsObject>
+        {
+            {  1, new IntAsObject() },
+            {  2, new IntAsObject() },
+        };
+
+        Assert.Equal(2, dict.Count);
+
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        IntAsObject itemVal = dict[1];
+        itemVal.Value = 1;
+        itemVal.Property = 2;
+
+        // Does change values in dictionary
+        Assert.Equal(1, dict[1].Value);
+        Assert.Equal(2, dict[1].Property);
+
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Value = 3;
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Property = 4;
+
+        Assert.Equal(3, dict[1].Value);
+        Assert.Equal(4, dict[1].Property);
+
+        ref IntAsObject itemRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 2);
+
+        Assert.Equal(0, itemRef.Value);
+        Assert.Equal(0, itemRef.Property);
+
+        itemRef.Value = 5;
+        itemRef.Property = 6;
+
+        Assert.Equal(5, itemRef.Value);
+        Assert.Equal(6, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        itemRef = new IntAsObject() { Value = 7, Property = 8 };
+
+        Assert.Equal(7, itemRef.Value);
+        Assert.Equal(8, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        // Check for null refs
+
+        Assert.True(Unsafe.IsNullRef(ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3)));
+        Assert.Throws<NullReferenceException>(() => SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3).Value = 9);
+
+        Assert.Equal(2, dict.Count);
+    }
+
+    [Fact]
+    public void SegmentedDictionary_GetValueRefOrNullRefLinkBreaksOnResize()
+    {
+        var dict = new SegmentedDictionary<int, Struct>
+        {
+            {  1, new Struct() },
+        };
+
+        Assert.Equal(1, dict.Count);
+
+        ref Struct itemRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1);
+
+        Assert.Equal(0, itemRef.Value);
+        Assert.Equal(0, itemRef.Property);
+
+        itemRef.Value = 1;
+        itemRef.Property = 2;
+
+        Assert.Equal(1, itemRef.Value);
+        Assert.Equal(2, itemRef.Property);
+        Assert.Equal(dict[1].Value, itemRef.Value);
+        Assert.Equal(dict[1].Property, itemRef.Property);
+
+        // Resize
+        dict.EnsureCapacity(100);
+        for (int i = 2; i <= 50; i++)
+        {
+            dict.Add(i, new Struct());
+        }
+
+        itemRef.Value = 3;
+        itemRef.Property = 4;
+
+        Assert.Equal(3, itemRef.Value);
+        Assert.Equal(4, itemRef.Property);
+
+        // Check connection broken
+        Assert.NotEqual(dict[1].Value, itemRef.Value);
+        Assert.NotEqual(dict[1].Property, itemRef.Property);
+
+        Assert.Equal(50, dict.Count);
+    }
+
+    [Fact]
+    public void ImmutableSegmentedDictionary_GetValueRefOrNullRefValueType()
+    {
+        var dict = ImmutableSegmentedDictionary.Create<int, Struct>();
+        dict = dict.Add(1, default);
+        dict = dict.Add(2, new Struct() { Value = 1, Property = 2 });
+
+        Assert.Equal(2, dict.Count);
+
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        Struct itemVal = dict[1];
+        itemVal.Value = 1;
+        itemVal.Property = 2;
+
+        // Does not change values in dictionary
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        ref readonly Struct itemRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 2);
+
+        Assert.Equal(1, itemRef.Value);
+        Assert.Equal(2, itemRef.Property);
+
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        // Check for null refs
+
+        Assert.True(Unsafe.IsNullRef(ref Unsafe.AsRef(in SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3))));
+        Assert.Throws<NullReferenceException>(() => SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3).Value);
+
+        Assert.Equal(2, dict.Count);
+    }
+
+    [Fact]
+    public void ImmutableSegmentedDictionary_GetValueRefOrNullRefClass()
+    {
+        var dict = ImmutableSegmentedDictionary.Create<int, IntAsObject>();
+        dict = dict.Add(1, new IntAsObject());
+        dict = dict.Add(2, new IntAsObject());
+
+        Assert.Equal(2, dict.Count);
+
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        IntAsObject itemVal = dict[1];
+        itemVal.Value = 1;
+        itemVal.Property = 2;
+
+        // Does change values in dictionary
+        Assert.Equal(1, dict[1].Value);
+        Assert.Equal(2, dict[1].Property);
+
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Value = 3;
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Property = 4;
+
+        Assert.Equal(3, dict[1].Value);
+        Assert.Equal(4, dict[1].Property);
+
+        ref readonly IntAsObject itemRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 2);
+
+        Assert.Equal(0, itemRef.Value);
+        Assert.Equal(0, itemRef.Property);
+
+        itemRef.Value = 5;
+        itemRef.Property = 6;
+
+        Assert.Equal(5, itemRef.Value);
+        Assert.Equal(6, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        // Check for null refs
+
+        Assert.True(Unsafe.IsNullRef(ref Unsafe.AsRef(in SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3))));
+        Assert.Throws<NullReferenceException>(() => SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3).Value = 9);
+
+        Assert.Equal(2, dict.Count);
+    }
+
+    [Fact]
+    public void ImmutableSegmentedDictionary_Builder_GetValueRefOrNullRefValueType()
+    {
+        var dict = ImmutableSegmentedDictionary.CreateBuilder<int, Struct>();
+        dict.Add(1, default);
+        dict.Add(2, default);
+
+        Assert.Equal(2, dict.Count);
+
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        Struct itemVal = dict[1];
+        itemVal.Value = 1;
+        itemVal.Property = 2;
+
+        // Does not change values in dictionary
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Value = 3;
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Property = 4;
+
+        Assert.Equal(3, dict[1].Value);
+        Assert.Equal(4, dict[1].Property);
+
+        ref Struct itemRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 2);
+
+        Assert.Equal(0, itemRef.Value);
+        Assert.Equal(0, itemRef.Property);
+
+        itemRef.Value = 5;
+        itemRef.Property = 6;
+
+        Assert.Equal(5, itemRef.Value);
+        Assert.Equal(6, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        itemRef = new Struct() { Value = 7, Property = 8 };
+
+        Assert.Equal(7, itemRef.Value);
+        Assert.Equal(8, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        // Check for null refs
+
+        Assert.True(Unsafe.IsNullRef(ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3)));
+        Assert.Throws<NullReferenceException>(() => SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3).Value = 9);
+
+        Assert.Equal(2, dict.Count);
+    }
+
+    [Fact]
+    public void ImmutableSegmentedDictionary_Builder_GetValueRefOrNullRefClass()
+    {
+        var dict = ImmutableSegmentedDictionary.CreateBuilder<int, IntAsObject>();
+        dict.Add(1, new IntAsObject());
+        dict.Add(2, new IntAsObject());
+
+        Assert.Equal(2, dict.Count);
+
+        Assert.Equal(0, dict[1].Value);
+        Assert.Equal(0, dict[1].Property);
+
+        IntAsObject itemVal = dict[1];
+        itemVal.Value = 1;
+        itemVal.Property = 2;
+
+        // Does change values in dictionary
+        Assert.Equal(1, dict[1].Value);
+        Assert.Equal(2, dict[1].Property);
+
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Value = 3;
+        SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1).Property = 4;
+
+        Assert.Equal(3, dict[1].Value);
+        Assert.Equal(4, dict[1].Property);
+
+        ref IntAsObject itemRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 2);
+
+        Assert.Equal(0, itemRef.Value);
+        Assert.Equal(0, itemRef.Property);
+
+        itemRef.Value = 5;
+        itemRef.Property = 6;
+
+        Assert.Equal(5, itemRef.Value);
+        Assert.Equal(6, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        itemRef = new IntAsObject() { Value = 7, Property = 8 };
+
+        Assert.Equal(7, itemRef.Value);
+        Assert.Equal(8, itemRef.Property);
+        Assert.Equal(dict[2].Value, itemRef.Value);
+        Assert.Equal(dict[2].Property, itemRef.Property);
+
+        // Check for null refs
+
+        Assert.True(Unsafe.IsNullRef(ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3)));
+        Assert.Throws<NullReferenceException>(() => SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3).Value = 9);
+
+        Assert.Equal(2, dict.Count);
+    }
+
+    [Fact]
+    public void ImmutableSegmentedDictionary_Builder_GetValueRefOrNullRefLinkBreaksOnResize()
+    {
+        var dict = ImmutableSegmentedDictionary.CreateBuilder<int, Struct>();
+        dict.Add(1, new Struct());
+
+        Assert.Equal(1, dict.Count);
+
+        ref Struct itemRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 1);
+
+        Assert.Equal(0, itemRef.Value);
+        Assert.Equal(0, itemRef.Property);
+
+        itemRef.Value = 1;
+        itemRef.Property = 2;
+
+        Assert.Equal(1, itemRef.Value);
+        Assert.Equal(2, itemRef.Property);
+        Assert.Equal(dict[1].Value, itemRef.Value);
+        Assert.Equal(dict[1].Property, itemRef.Property);
+
+        // Resize
+        dict.GetTestAccessor().GetOrCreateMutableDictionary().EnsureCapacity(100);
+        for (int i = 2; i <= 50; i++)
+        {
+            dict.Add(i, new Struct());
+        }
+
+        itemRef.Value = 3;
+        itemRef.Property = 4;
+
+        Assert.Equal(3, itemRef.Value);
+        Assert.Equal(4, itemRef.Property);
+
+        // Check connection broken
+        Assert.NotEqual(dict[1].Value, itemRef.Value);
+        Assert.NotEqual(dict[1].Property, itemRef.Property);
+
+        Assert.Equal(50, dict.Count);
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedListFromNullSegmentedList()
+    {
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<int>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<int?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<Guid>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<Guid?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<string>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<CustomClass>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<ManagedCustomStruct>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<ManagedCustomStruct?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<UnmanagedCustomStruct>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<UnmanagedCustomStruct?>(null).IsDefault);
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedListFromEmptySegmentedList()
+    {
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<int>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<int?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<Guid>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<Guid?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<string>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<CustomClass>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<ManagedCustomStruct>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<ManagedCustomStruct?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<UnmanagedCustomStruct>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<UnmanagedCustomStruct?>(0)).IsEmpty);
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedListFromExistingSegmentedList()
+    {
+        static void test<T>()
+        {
+            SegmentedList<T> list = new SegmentedList<T>(new T[17]);
+            ImmutableSegmentedList<T> immutableList = SegmentedCollectionsMarshal.AsImmutableSegmentedList(list);
+
+            Assert.False(immutableList.IsDefault);
+            Assert.Equal(17, immutableList.Count);
+
+            ref T expectedRef = ref list.GetTestAccessor().Items[0];
+            ref T actualRef = ref Unsafe.AsRef(in immutableList.ItemRef(0));
+
+            Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
+        }
+
+        test<int>();
+        test<int?>();
+        test<Guid>();
+        test<Guid?>();
+        test<string>();
+        test<CustomClass>();
+        test<ManagedCustomStruct>();
+        test<ManagedCustomStruct?>();
+        test<UnmanagedCustomStruct>();
+        test<UnmanagedCustomStruct?>();
+    }
+
+    [Fact]
+    public void AsSegmentedListFromDefaultImmutableSegmentedList()
+    {
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<int>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<int?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<Guid>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<Guid?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<string>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<CustomClass>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<ManagedCustomStruct>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<ManagedCustomStruct?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<UnmanagedCustomStruct>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedList<UnmanagedCustomStruct?>(default));
+    }
+
+    [Fact]
+    public void AsSegmentedListFromEmptyImmutableSegmentedList()
+    {
+        static void test<T>()
+        {
+            SegmentedList<T>? list = SegmentedCollectionsMarshal.AsSegmentedList(ImmutableSegmentedList<T>.Empty);
+
+            Assert.NotNull(list);
+            Assert.Empty(list);
+        }
+
+        test<int>();
+        test<int?>();
+        test<Guid>();
+        test<Guid?>();
+        test<string>();
+        test<CustomClass>();
+        test<ManagedCustomStruct>();
+        test<ManagedCustomStruct?>();
+        test<UnmanagedCustomStruct>();
+        test<UnmanagedCustomStruct?>();
+    }
+
+    [Fact]
+    public void AsSegmentedListFromConstructedImmutableSegmentedList()
+    {
+        static void test<T>()
+        {
+            ImmutableSegmentedList<T> immutableList = ImmutableSegmentedList.Create(new T[17]);
+            SegmentedList<T>? list = SegmentedCollectionsMarshal.AsSegmentedList(immutableList);
+
+            AssertEx.NotNull(list);
+            Assert.Equal(17, list.Count);
+
+            ref T expectedRef = ref Unsafe.AsRef(in immutableList.ItemRef(0));
+            ref T actualRef = ref list.GetTestAccessor().Items[0];
+
+            Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
+        }
+
+        test<int>();
+        test<int?>();
+        test<Guid>();
+        test<Guid?>();
+        test<string>();
+        test<CustomClass>();
+        test<ManagedCustomStruct>();
+        test<ManagedCustomStruct?>();
+        test<UnmanagedCustomStruct>();
+        test<UnmanagedCustomStruct?>();
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedHashSetFromNullSegmentedHashSet()
+    {
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<int>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<int?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<Guid>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<Guid?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<string>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<CustomClass>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<ManagedCustomStruct>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<ManagedCustomStruct?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<UnmanagedCustomStruct>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<UnmanagedCustomStruct?>(null).IsDefault);
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedHashSetFromEmptySegmentedHashSet()
+    {
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<int>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<int?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<Guid>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<Guid?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<string>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<CustomClass>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<ManagedCustomStruct>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<ManagedCustomStruct?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<UnmanagedCustomStruct>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<UnmanagedCustomStruct?>(0)).IsEmpty);
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedHashSetFromExistingSegmentedHashSet()
+    {
+        static void test<T>(IEnumerable<T> values)
+        {
+            SegmentedHashSet<T> set = new SegmentedHashSet<T>(values);
+            ImmutableSegmentedHashSet<T> immutableHashSet = SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(set);
+
+            Assert.False(immutableHashSet.IsDefault);
+            Assert.Equal(17, immutableHashSet.Count);
+
+            Assert.Same(set, SegmentedCollectionsMarshal.AsSegmentedHashSet(immutableHashSet));
+
+            // Currently SegmentedHashSet<T> does not provide direct ref access to values, so the following tests
+            // cannot be implemented in an obvious way.
+
+            //ref T expectedRef = ref set.GetTestAccessor().Items[0];
+            //ref T actualRef = ref Unsafe.AsRef(in immutableHashSet.ItemRef(0));
+
+            //Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
+        }
+
+        test<int>(Enumerable.Range(0, 17));
+        test<int?>(Enumerable.Range(0, 17).Cast<int?>());
+        test<Guid>(Enumerable.Range(0, 17).Select(_ => Guid.NewGuid()));
+        test<Guid?>(Enumerable.Range(0, 17).Select(_ => (Guid?)Guid.NewGuid()));
+        test<string>(Enumerable.Range(0, 17).Select(_ => Guid.NewGuid().ToString()));
+        test<CustomClass>(Enumerable.Range(0, 17).Select(_ => new CustomClass()));
+        test<ManagedCustomStruct>(Enumerable.Range(0, 17).Select(_ => new ManagedCustomStruct() { Bar = Guid.NewGuid() }));
+        test<ManagedCustomStruct?>(Enumerable.Range(0, 17).Select(_ => (ManagedCustomStruct?)new ManagedCustomStruct() { Bar = Guid.NewGuid() }));
+        test<UnmanagedCustomStruct>(Enumerable.Range(0, 17).Select(_ => new UnmanagedCustomStruct() { Foo = Guid.NewGuid() }));
+        test<UnmanagedCustomStruct?>(Enumerable.Range(0, 17).Select(_ => (UnmanagedCustomStruct?)new UnmanagedCustomStruct() { Foo = Guid.NewGuid() }));
+    }
+
+    [Fact]
+    public void AsSegmentedHashSetFromDefaultImmutableSegmentedHashSet()
+    {
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<int>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<int?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<Guid>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<Guid?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<string>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<CustomClass>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<ManagedCustomStruct>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<ManagedCustomStruct?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<UnmanagedCustomStruct>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedHashSet<UnmanagedCustomStruct?>(default));
+    }
+
+    [Fact]
+    public void AsSegmentedHashSetFromEmptyImmutableSegmentedHashSet()
+    {
+        static void test<T>()
+        {
+            SegmentedHashSet<T>? set = SegmentedCollectionsMarshal.AsSegmentedHashSet(ImmutableSegmentedHashSet<T>.Empty);
+
+            Assert.NotNull(set);
+            Assert.Empty(set);
+        }
+
+        test<int>();
+        test<int?>();
+        test<Guid>();
+        test<Guid?>();
+        test<string>();
+        test<CustomClass>();
+        test<ManagedCustomStruct>();
+        test<ManagedCustomStruct?>();
+        test<UnmanagedCustomStruct>();
+        test<UnmanagedCustomStruct?>();
+    }
+
+    [Fact]
+    public void AsSegmentedHashSetFromConstructedImmutableSegmentedHashSet()
+    {
+        static void test<T>(IEnumerable<T> values)
+        {
+            ImmutableSegmentedHashSet<T> immutableHashSet = ImmutableSegmentedHashSet.CreateRange(values);
+            SegmentedHashSet<T>? set = SegmentedCollectionsMarshal.AsSegmentedHashSet(immutableHashSet);
+
+            AssertEx.NotNull(set);
+            Assert.Equal(17, set.Count);
+
+            Assert.Same(set, SegmentedCollectionsMarshal.AsSegmentedHashSet(immutableHashSet));
+
+            // Currently SegmentedHashSet<T> does not provide direct ref access to values, so the following tests
+            // cannot be implemented in an obvious way.
+
+            //ref T expectedRef = ref Unsafe.AsRef(in immutableHashSet.ItemRef(0));
+            //ref T actualRef = ref set.GetTestAccessor().Items[0];
+
+            //Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
+        }
+
+        test<int>(Enumerable.Range(0, 17));
+        test<int?>(Enumerable.Range(0, 17).Cast<int?>());
+        test<Guid>(Enumerable.Range(0, 17).Select(_ => Guid.NewGuid()));
+        test<Guid?>(Enumerable.Range(0, 17).Select(_ => (Guid?)Guid.NewGuid()));
+        test<string>(Enumerable.Range(0, 17).Select(_ => Guid.NewGuid().ToString()));
+        test<CustomClass>(Enumerable.Range(0, 17).Select(_ => new CustomClass()));
+        test<ManagedCustomStruct>(Enumerable.Range(0, 17).Select(_ => new ManagedCustomStruct() { Bar = Guid.NewGuid() }));
+        test<ManagedCustomStruct?>(Enumerable.Range(0, 17).Select(_ => (ManagedCustomStruct?)new ManagedCustomStruct() { Bar = Guid.NewGuid() }));
+        test<UnmanagedCustomStruct>(Enumerable.Range(0, 17).Select(_ => new UnmanagedCustomStruct() { Foo = Guid.NewGuid() }));
+        test<UnmanagedCustomStruct?>(Enumerable.Range(0, 17).Select(_ => (UnmanagedCustomStruct?)new UnmanagedCustomStruct() { Foo = Guid.NewGuid() }));
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedDictionaryFromNullSegmentedDictionary()
+    {
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<int, int>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<int, int?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<Guid, Guid>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<Guid, Guid?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<string, string>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<CustomClass, CustomClass>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct?>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct>(null).IsDefault);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct?>(null).IsDefault);
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedDictionaryFromEmptySegmentedDictionary()
+    {
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<int, int>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<int, int?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<Guid, Guid>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<Guid, Guid?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<string, string>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<CustomClass, CustomClass>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct?>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct>(0)).IsEmpty);
+        Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct?>(0)).IsEmpty);
+    }
+
+    [Fact]
+    public void AsImmutableSegmentedDictionaryFromExistingSegmentedDictionary()
+    {
+        static void test<TValue>(Func<TValue> createValue)
+        {
+            SegmentedDictionary<int, TValue> dictionary = new SegmentedDictionary<int, TValue>(Enumerable.Range(0, 17).Select(x => new KeyValuePair<int, TValue>(x, createValue())));
+            ImmutableSegmentedDictionary<int, TValue> immutableDictionary = SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(dictionary);
+
+            Assert.False(immutableDictionary.IsDefault);
+            Assert.Equal(17, immutableDictionary.Count);
+
+            ref TValue expectedRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dictionary, 0);
+            ref TValue actualRef = ref Unsafe.AsRef(in SegmentedCollectionsMarshal.GetValueRefOrNullRef(immutableDictionary, 0));
+
+            Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
+        }
+
+        test<int>(() => default);
+        test<int?>(() => null);
+        test<Guid>(() => default);
+        test<Guid?>(() => null);
+        test<string>(() => "");
+        test<CustomClass>(() => new CustomClass());
+        test<ManagedCustomStruct>(() => new ManagedCustomStruct());
+        test<ManagedCustomStruct?>(() => new ManagedCustomStruct());
+        test<UnmanagedCustomStruct>(() => new UnmanagedCustomStruct());
+        test<UnmanagedCustomStruct?>(() => new UnmanagedCustomStruct());
+    }
+
+    [Fact]
+    public void AsSegmentedDictionaryFromDefaultImmutableSegmentedDictionary()
+    {
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<int, int>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<int, int?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<Guid, Guid>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<Guid, Guid?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<string, string>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<CustomClass, CustomClass>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct?>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct>(default));
+        Assert.Null(SegmentedCollectionsMarshal.AsSegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct?>(default));
+    }
+
+    [Fact]
+    public void AsSegmentedDictionaryFromEmptyImmutableSegmentedDictionary()
+    {
+        static void test<T>()
+        {
+            SegmentedDictionary<int, T>? dictionary = SegmentedCollectionsMarshal.AsSegmentedDictionary(ImmutableSegmentedDictionary<int, T>.Empty);
+
+            Assert.NotNull(dictionary);
+            Assert.Empty(dictionary);
+        }
+
+        test<int>();
+        test<int?>();
+        test<Guid>();
+        test<Guid?>();
+        test<string>();
+        test<CustomClass>();
+        test<ManagedCustomStruct>();
+        test<ManagedCustomStruct?>();
+        test<UnmanagedCustomStruct>();
+        test<UnmanagedCustomStruct?>();
+    }
+
+    [Fact]
+    public void AsSegmentedDictionaryFromConstructedImmutableSegmentedDictionary()
+    {
+        static void test<T>(Func<T> createValue)
+        {
+            ImmutableSegmentedDictionary<int, T> immutableDictionary = ImmutableSegmentedDictionary.CreateRange(Enumerable.Range(0, 17).Select(x => new KeyValuePair<int, T>(x, createValue())));
+            SegmentedDictionary<int, T>? dictionary = SegmentedCollectionsMarshal.AsSegmentedDictionary(immutableDictionary);
+
+            AssertEx.NotNull(dictionary);
+            Assert.Equal(17, dictionary.Count);
+
+            ref T expectedRef = ref Unsafe.AsRef(in SegmentedCollectionsMarshal.GetValueRefOrNullRef(immutableDictionary, 0));
+            ref T actualRef = ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dictionary, 0);
+
+            Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
+        }
+
+        test<int>(() => default);
+        test<int?>(() => null);
+        test<Guid>(() => default);
+        test<Guid?>(() => null);
+        test<string>(() => "");
+        test<CustomClass>(() => new CustomClass());
+        test<ManagedCustomStruct>(() => new ManagedCustomStruct());
+        test<ManagedCustomStruct?>(() => new ManagedCustomStruct());
+        test<UnmanagedCustomStruct>(() => new UnmanagedCustomStruct());
+        test<UnmanagedCustomStruct?>(() => new UnmanagedCustomStruct());
+    }
+
+    private struct Struct
+    {
+        public int Value;
+        public int Property { get; set; }
+    }
+
+    private class IntAsObject
+    {
+        public int Value;
+        public int Property { get; set; }
+    }
+
+    public class CustomClass
+    {
+        public object? Foo;
+        public Guid Bar;
+    }
+
+    public struct ManagedCustomStruct
+    {
+        public object? Foo;
+        public Guid Bar;
+    }
+
+    public struct UnmanagedCustomStruct
+    {
+        public Guid Foo;
+        public int Bar;
+    }
+}
diff --git a/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+Builder.cs b/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+Builder.cs
index 26f264cf961fe..c813f54169bb4 100644
--- a/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+Builder.cs
+++ b/src/Dependencies/Collections/ImmutableSegmentedDictionary`2+Builder.cs
@@ -242,6 +242,15 @@ void IDictionary.Remove(object key)
 
             void ICollection.CopyTo(Array array, int index)
                 => ((ICollection)ReadOnlyDictionary).CopyTo(array, index);
+
+            internal TestAccessor GetTestAccessor()
+                => new TestAccessor(this);
+
+            internal readonly struct TestAccessor(Builder instance)
+            {
+                internal SegmentedDictionary<TKey, TValue> GetOrCreateMutableDictionary()
+                    => instance.GetOrCreateMutableDictionary();
+            }
         }
     }
 }
diff --git a/src/Dependencies/Collections/SegmentedList`1.cs b/src/Dependencies/Collections/SegmentedList`1.cs
index dd36dc375bf26..894f102b6318c 100644
--- a/src/Dependencies/Collections/SegmentedList`1.cs
+++ b/src/Dependencies/Collections/SegmentedList`1.cs
@@ -1230,5 +1230,13 @@ void IEnumerator.Reset()
                 _current = default;
             }
         }
+
+        internal TestAccessor GetTestAccessor()
+            => new TestAccessor(this);
+
+        internal readonly struct TestAccessor(SegmentedList<T> instance)
+        {
+            public ref SegmentedArray<T> Items => ref instance._items;
+        }
     }
 }

From 4d3093f82f2e9c940bc07b10302343557dd36067 Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <Maryam.Ariyan@microsoft.com>
Date: Mon, 11 Mar 2024 09:09:50 -0700
Subject: [PATCH 008/170] Allow VS Code to provide razor source geneator
 references.

---
 .../LanguageServerTestComposition.cs          |  1 +
 .../HostDiagnosticAnalyzerProvider.cs         | 61 ++++++++++++++++++-
 .../LanguageServerWorkspaceFactory.cs         |  4 +-
 .../Program.cs                                |  9 +++
 .../ServerConfigurationFactory.cs             |  1 +
 .../ProjectSystem/ProjectSystemProject.cs     |  1 +
 6 files changed, 74 insertions(+), 3 deletions(-)

diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
index bf38114258d83..3422dc1c30a16 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
@@ -32,6 +32,7 @@ public static Task<ExportProvider> CreateExportProviderAsync(ILoggerFactory logg
             SessionId: null,
             ExtensionAssemblyPaths: [],
             DevKitDependencyPath: devKitDependencyPath,
+            DevKitRazorOutputPath: null,
             ExtensionLogDirectory: string.Empty);
         var extensionAssemblyManager = ExtensionAssemblyManager.Create(serverConfiguration, loggerFactory);
         return ExportProviderBuilder.CreateExportProviderAsync(extensionAssemblyManager, devKitDependencyPath, loggerFactory: loggerFactory);
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
index 8bbe02aa13604..517275e99ad9a 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
@@ -3,15 +3,72 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
+using System.Reflection;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Workspaces.ProjectSystem;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 internal class HostDiagnosticAnalyzerProvider : IHostDiagnosticAnalyzerProvider
 {
+    /// <summary>
+    /// The directory where the analyzers are located
+    /// </summary>
+    public string? AnalyzerDirectory { get; set; }
+
+    private const string RazorVsixExtensionId = "Microsoft.VisualStudio.RazorExtension";
+    private static readonly HashSet<string> s_razorSourceGeneratorAssemblyNames = new[] {
+        "Microsoft.NET.Sdk.Razor.SourceGenerators",
+        "Microsoft.CodeAnalysis.Razor.Compiler.SourceGenerators",
+        "Microsoft.CodeAnalysis.Razor.Compiler",
+    }.ToHashSet<string>();
+
+    public HostDiagnosticAnalyzerProvider(string? analyzerDirectory)
+    {
+        AnalyzerDirectory = analyzerDirectory;
+    }
+
     public ImmutableArray<(AnalyzerFileReference reference, string extensionId)> GetAnalyzerReferencesInExtensions()
     {
-        // Right now we don't expose any way for the extensions in VS Code to provide analyzer references.
-        return ImmutableArray<(AnalyzerFileReference reference, string extensionId)>.Empty;
+        if (AnalyzerDirectory == null)
+        {
+            return ImmutableArray<(AnalyzerFileReference reference, string extensionId)>.Empty;
+        }
+
+        var analyzerReferences = new List<(AnalyzerFileReference, string)>();
+
+        // Get all the .dll files in the directory
+        var analyzerFiles = Directory.GetFiles(AnalyzerDirectory, "*.dll");
+
+        foreach (var analyzerFile in analyzerFiles)
+        {
+            // Create an AnalyzerFileReference for each file
+            var analyzerReference = new AnalyzerFileReference(analyzerFile, new SimpleAnalyzerAssemblyLoader());
+
+            if (s_razorSourceGeneratorAssemblyNames.Any(
+                name => analyzerReference.FullPath.Contains(name, StringComparison.OrdinalIgnoreCase)))
+            {
+                // Add the reference to the list, using the file name as the extension ID
+                analyzerReferences.Add((analyzerReference, RazorVsixExtensionId));
+            }
+        }
+
+        return analyzerReferences.ToImmutableArray();
+    }
+
+    private class SimpleAnalyzerAssemblyLoader : IAnalyzerAssemblyLoader
+    {
+        public void AddDependencyLocation(string fullPath)
+        {
+            // This method is used to add a path that should be probed for analyzer dependencies.
+            // In this simple implementation, we do nothing.
+        }
+
+        public Assembly LoadFromPath(string fullPath)
+        {
+            // This method is used to load an analyzer assembly from the specified path.
+            // In this simple implementation, we use Assembly.LoadFrom to load the assembly.
+            return Assembly.LoadFrom(fullPath);
+        }
     }
 }
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs
index 3e397764fc809..82055c4c58a46 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs
@@ -29,6 +29,7 @@ public LanguageServerWorkspaceFactory(
         IFileChangeWatcher fileChangeWatcher,
         [ImportMany] IEnumerable<Lazy<IDynamicFileInfoProvider, Host.Mef.FileExtensionsMetadata>> dynamicFileInfoProviders,
         ProjectTargetFrameworkManager projectTargetFrameworkManager,
+        ServerConfigurationFactory serverConfigurationFactory,
         ILoggerFactory loggerFactory)
     {
         _logger = loggerFactory.CreateLogger(nameof(LanguageServerWorkspaceFactory));
@@ -40,10 +41,11 @@ public LanguageServerWorkspaceFactory(
 
         analyzerLoader.InitializeDiagnosticsServices(Workspace);
 
+        var devKitRazorOutputPath = serverConfigurationFactory?.ServerConfiguration?.DevKitRazorOutputPath;
         ProjectSystemHostInfo = new ProjectSystemHostInfo(
             DynamicFileInfoProviders: dynamicFileInfoProviders.ToImmutableArray(),
             new ProjectSystemDiagnosticSource(),
-            new HostDiagnosticAnalyzerProvider());
+            new HostDiagnosticAnalyzerProvider(devKitRazorOutputPath));
 
         TargetFrameworkManager = projectTargetFrameworkManager;
     }
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
index ef7e08dc3842b..ebd2790dc7441 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
@@ -198,6 +198,12 @@ static CliRootCommand CreateCommandLineParser()
         Required = false
     };
 
+    var devKitRazorOutputPathOption = new CliOption<string?>("--devKitRazorOutputPath")
+    {
+        Description = "Full path to the Razor output path used with DevKit (optional).",
+        Required = false
+    };
+
     var rootCommand = new CliRootCommand()
     {
         debugOption,
@@ -208,6 +214,7 @@ static CliRootCommand CreateCommandLineParser()
         sessionIdOption,
         extensionAssemblyPathsOption,
         devKitDependencyPathOption,
+        devKitRazorOutputPathOption,
         extensionLogDirectoryOption
     };
     rootCommand.SetAction((parseResult, cancellationToken) =>
@@ -219,6 +226,7 @@ static CliRootCommand CreateCommandLineParser()
         var sessionId = parseResult.GetValue(sessionIdOption);
         var extensionAssemblyPaths = parseResult.GetValue(extensionAssemblyPathsOption) ?? [];
         var devKitDependencyPath = parseResult.GetValue(devKitDependencyPathOption);
+        var devKitRazorOutputPath = parseResult.GetValue(devKitRazorOutputPathOption);
         var extensionLogDirectory = parseResult.GetValue(extensionLogDirectoryOption)!;
 
         var serverConfiguration = new ServerConfiguration(
@@ -229,6 +237,7 @@ static CliRootCommand CreateCommandLineParser()
             SessionId: sessionId,
             ExtensionAssemblyPaths: extensionAssemblyPaths,
             DevKitDependencyPath: devKitDependencyPath,
+            DevKitRazorOutputPath: devKitRazorOutputPath,
             ExtensionLogDirectory: extensionLogDirectory);
 
         return RunAsync(serverConfiguration, cancellationToken);
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs
index a5b41daa31870..ce7496dd8d9f7 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs
@@ -49,4 +49,5 @@ internal record class ServerConfiguration(
     string? SessionId,
     IEnumerable<string> ExtensionAssemblyPaths,
     string? DevKitDependencyPath,
+    string? DevKitRazorOutputPath,
     string ExtensionLogDirectory);
diff --git a/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs b/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs
index 416ec19fa02af..9e900ceeaf494 100644
--- a/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs
+++ b/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs
@@ -1002,6 +1002,7 @@ public void RemoveAnalyzerReference(string fullPath)
 
     private OneOrMany<string> GetMappedAnalyzerPaths(string fullPath)
     {
+        fullPath = Path.GetFullPath(fullPath);
         // Map all files in the SDK directory that contains the Razor source generator to source generator files loaded from VSIX.
         // Include the generator and all its dependencies shipped in VSIX, discard the generator and all dependencies in the SDK
         if (fullPath.LastIndexOf(s_razorSourceGeneratorSdkDirectory, StringComparison.OrdinalIgnoreCase) + s_razorSourceGeneratorSdkDirectory.Length - 1 ==

From e3a92bf7ed4bc16d212a3000cd9378a3e777c7f1 Mon Sep 17 00:00:00 2001
From: David Barbet <dabarbet@microsoft.com>
Date: Thu, 22 Feb 2024 14:07:30 -0800
Subject: [PATCH 009/170] Convert Clasp into a source package

---
 Roslyn.sln                                    | 16 +++-
 ...crosoft.CodeAnalysis.EditorFeatures.csproj |  3 +
 .../LanguageServer/TestOutputLspLogger.cs     |  2 +-
 ...uageServerProtocol.Framework.Binary.csproj | 25 +++++++
 .../ExampleLanguageServer.cs                  |  2 +-
 .../ExampleRequestContext.cs                  |  2 +-
 ...ageServerProtocol.Framework.Example.csproj |  5 +-
 .../MultiRegisteringHandler.cs                |  2 +-
 .../Mocks/NoOpLspLogger.cs                    |  2 +-
 .../Mocks/TestMethodHandlers.cs               |  8 +-
 .../Mocks/TestRequestContext.cs               |  4 +-
 .../AbstractHandlerProvider.cs                |  7 ++
 .../AbstractLanguageServer.cs                 | 17 ++++-
 .../AbstractLspLogger.cs                      |  7 ++
 .../AbstractRequestContextFactory.cs          |  7 ++
 .../AbstractRequestScope.cs                   |  7 ++
 .../AbstractTelemetryService.cs               |  7 ++
 .../BannedSymbols.txt                         | 73 +++++++++++++++++++
 .../BreakingChanges.md                        | 44 -----------
 .../HandlerProvider.cs                        |  3 +
 .../Handlers/InitializeHandler.cs             |  9 ++-
 .../Handlers/InitializedHandler.cs            |  9 ++-
 .../IHandlerProvider.cs                       |  7 ++
 .../IInitializeManager.cs                     |  7 ++
 .../ILifeCycleManager.cs                      |  8 +-
 .../ILspLogger.cs                             |  7 ++
 .../ILspServices.cs                           |  8 +-
 .../IMethodHandler.cs                         |  7 ++
 .../INotificationHandler.cs                   | 11 +++
 .../IQueueItem.cs                             |  7 ++
 .../IRequestContextFactory.cs                 |  7 ++
 .../IRequestExecutionQueue.cs                 |  7 ++
 .../IRequestHandler.cs                        | 13 +++-
 .../ITextDocumentIdentifierHandler.cs         | 11 +++
 .../LanguageServerConstants.cs                |  7 ++
 .../LanguageServerEndpointAttribute.cs        |  7 ++
 ...ageServerProtocol.Framework.Package.csproj | 45 ++++++++++++
 ...eServerProtocol.Framework.Shared.projitems | 42 +++++++++++
 ...uageServerProtocol.Framework.Shared.shproj | 16 ++++
 ...monLanguageServerProtocol.Framework.csproj | 24 ------
 .../QueueItem.cs                              |  5 ++
 .../RequestExecutionQueue.cs                  |  9 +++
 .../RequestHandlerMetadata.cs                 |  7 ++
 .../RequestShutdownEventArgs.cs               |  7 ++
 .../WrappedHandlerProvider.cs                 |  3 +
 .../contentFiles/.editorconfig                | 10 +++
 .../xlf/LSPFrameworkResources.cs.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.de.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.es.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.fr.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.it.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.ja.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.ko.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.pl.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.pt-BR.xlf       | 42 -----------
 .../xlf/LSPFrameworkResources.ru.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.tr.xlf          | 42 -----------
 .../xlf/LSPFrameworkResources.zh-Hans.xlf     | 42 -----------
 .../xlf/LSPFrameworkResources.zh-Hant.xlf     | 42 -----------
 ...odeAnalysis.LanguageServer.Protocol.csproj | 16 ++--
 ...ExternalAccess.CompilerDeveloperSDK.csproj |  1 -
 ....CodeAnalysis.ExternalAccess.FSharp.csproj |  4 +
 ...t.CodeAnalysis.ExternalAccess.Razor.csproj |  4 +
 .../Xaml/External/IXamlRequestHandler.cs      |  7 +-
 .../Xaml/InternalAPI.Unshipped.txt            |  2 +
 ...ft.CodeAnalysis.ExternalAccess.Xaml.csproj |  5 +-
 ...osoft.VisualStudio.LanguageServices.csproj |  3 +
 .../Setup/Roslyn.VisualStudio.Setup.csproj    |  2 +-
 ...eAnalysis.Workspaces.Test.Utilities.csproj |  3 +
 69 files changed, 485 insertions(+), 651 deletions(-)
 create mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Binary/Microsoft.CommonLanguageServerProtocol.Framework.Binary.csproj
 create mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/BannedSymbols.txt
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/BreakingChanges.md
 create mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Package.csproj
 create mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems
 create mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Shared.shproj
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.csproj
 create mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/contentFiles/.editorconfig
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.cs.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.de.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.es.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.fr.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.it.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ja.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ko.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.pl.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.pt-BR.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ru.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.tr.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.zh-Hans.xlf
 delete mode 100644 src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.zh-Hant.xlf

diff --git a/Roslyn.sln b/Roslyn.sln
index a803ad06d2b5f..df9b1302453dd 100644
--- a/Roslyn.sln
+++ b/Roslyn.sln
@@ -494,7 +494,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GenerateRulesMissingDocumen
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.EndToEnd.UnitTests", "src\Compilers\CSharp\Test\EndToEnd\Microsoft.CodeAnalysis.CSharp.EndToEnd.UnitTests.csproj", "{C247414A-8946-4BAB-BE1F-C82B90C63EF6}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CommonLanguageServerProtocol.Framework", "src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.csproj", "{D2589BCE-4F2E-4113-B7E7-37392C0C5492}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CommonLanguageServerProtocol.Framework.Package", "src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.Package.csproj", "{D2589BCE-4F2E-4113-B7E7-37392C0C5492}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CommonLanguageServerProtocol.Framework.Example", "src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework.Example\Microsoft.CommonLanguageServerProtocol.Framework.Example.csproj", "{BD9539EB-AA5E-4E67-AC7F-97D7CBC4D0C9}"
 EndProject
@@ -544,6 +544,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Feat
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Features.Test.Utilities", "src\Features\TestUtilities\Microsoft.CodeAnalysis.Features.Test.Utilities.csproj", "{5762E483-75CE-4328-A410-511F30737712}"
 EndProject
+Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Microsoft.CommonLanguageServerProtocol.Framework.Shared", "src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.Shared.shproj", "{64EADED3-4B5D-4431-BBE5-A4ABA1C38C00}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CommonLanguageServerProtocol.Framework.Binary", "src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework.Binary\Microsoft.CommonLanguageServerProtocol.Framework.Binary.csproj", "{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -1346,6 +1350,10 @@ Global
 		{5762E483-75CE-4328-A410-511F30737712}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5762E483-75CE-4328-A410-511F30737712}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5762E483-75CE-4328-A410-511F30737712}.Release|Any CPU.Build.0 = Release|Any CPU
+		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -1595,6 +1603,8 @@ Global
 		{4D9D7A28-BB44-4F3F-81DA-14F39B853718} = {CC126D03-7EAC-493F-B187-DCDEE1EF6A70}
 		{5BABC440-4F1B-46E8-9068-DD7F02ED25D3} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
 		{5762E483-75CE-4328-A410-511F30737712} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
+		{64EADED3-4B5D-4431-BBE5-A4ABA1C38C00} = {D449D505-CC6A-4E0B-AF1B-976E2D0AE67A}
+		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D} = {D449D505-CC6A-4E0B-AF1B-976E2D0AE67A}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {604E6B91-7BC0-4126-AE07-D4D2FEFC3D29}
@@ -1636,7 +1646,10 @@ Global
 		src\Analyzers\Core\CodeFixes\CodeFixes.projitems*{5ff1e493-69cc-4d0b-83f2-039f469a04e1}*SharedItemsImports = 5
 		src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\WorkspaceExtensions.projitems*{5ff1e493-69cc-4d0b-83f2-039f469a04e1}*SharedItemsImports = 5
 		src\ExpressionEvaluator\CSharp\Source\ResultProvider\CSharpResultProvider.projitems*{60db272a-21c9-4e8d-9803-ff4e132392c8}*SharedItemsImports = 5
+		src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems*{64eaded3-4b5d-4431-bbe5-a4aba1c38c00}*SharedItemsImports = 13
+		src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems*{686bf57e-a6ff-467b-aab3-44de916a9772}*SharedItemsImports = 5
 		src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CSharpCompilerExtensions.projitems*{699fea05-aea7-403d-827e-53cf4e826955}*SharedItemsImports = 13
+		src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems*{730cadba-701f-4722-9b6f-1fcc0df2c95d}*SharedItemsImports = 5
 		src\ExpressionEvaluator\VisualBasic\Source\ResultProvider\BasicResultProvider.projitems*{76242a2d-2600-49dd-8c15-fea07ecb1843}*SharedItemsImports = 5
 		src\Analyzers\Core\Analyzers\Analyzers.projitems*{76e96966-4780-4040-8197-bde2879516f4}*SharedItemsImports = 13
 		src\Analyzers\VisualBasic\Tests\VisualBasicAnalyzers.UnitTests.projitems*{7b7f4153-ae93-4908-b8f0-430871589f83}*SharedItemsImports = 13
@@ -1662,6 +1675,7 @@ Global
 		src\Dependencies\PooledObjects\Microsoft.CodeAnalysis.PooledObjects.projitems*{c1930979-c824-496b-a630-70f5369a636f}*SharedItemsImports = 13
 		src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\VisualBasicCompilerExtensions.projitems*{cec0dce7-8d52-45c3-9295-fc7b16bd2451}*SharedItemsImports = 13
 		src\Compilers\Core\AnalyzerDriver\AnalyzerDriver.projitems*{d0bc9be7-24f6-40ca-8dc6-fcb93bd44b34}*SharedItemsImports = 13
+		src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework.Shared\Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems*{d2589bce-4f2e-4113-b7e7-37392c0c5492}*SharedItemsImports = 5
 		src\Dependencies\CodeAnalysis.Debugging\Microsoft.CodeAnalysis.Debugging.projitems*{d73adf7d-2c1c-42ae-b2ab-edc9497e4b71}*SharedItemsImports = 13
 		src\Compilers\Server\VBCSCompiler\VBCSCompilerCommandLine.projitems*{d8ef0777-9d65-4849-a7d6-ac81e58e2317}*SharedItemsImports = 13
 		src\Analyzers\CSharp\CodeFixes\CSharpCodeFixes.projitems*{da973826-c985-4128-9948-0b445e638bdb}*SharedItemsImports = 13
diff --git a/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj b/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj
index 6652c4d9e4045..f59ef2b19bdc1 100644
--- a/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj
+++ b/src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj
@@ -36,6 +36,9 @@
     <PackageReference Include="Microsoft.ServiceHub.Client" />
     <PackageReference Include="Microsoft.VisualStudio.Debugger.Contracts" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Utilities\IsExternalInit.cs" />
+  </ItemGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="DynamicProxyGenAssembly2" Key="$(MoqPublicKey)" LoadsWithinVisualStudio="false" />
     <InternalsVisibleTo Include="IdeBenchmarks" />
diff --git a/src/EditorFeatures/TestUtilities/LanguageServer/TestOutputLspLogger.cs b/src/EditorFeatures/TestUtilities/LanguageServer/TestOutputLspLogger.cs
index 45f51a01f86d1..c8ba5e8bdbd99 100644
--- a/src/EditorFeatures/TestUtilities/LanguageServer/TestOutputLspLogger.cs
+++ b/src/EditorFeatures/TestUtilities/LanguageServer/TestOutputLspLogger.cs
@@ -8,7 +8,7 @@
 
 namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests;
 
-public sealed class TestOutputLspLogger : AbstractLspLogger, ILspService
+internal sealed class TestOutputLspLogger : AbstractLspLogger, ILspService
 {
     private readonly ITestOutputHelper _testOutputHelper;
     public TestOutputLspLogger(ITestOutputHelper testOutputHelper)
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Binary/Microsoft.CommonLanguageServerProtocol.Framework.Binary.csproj b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Binary/Microsoft.CommonLanguageServerProtocol.Framework.Binary.csproj
new file mode 100644
index 0000000000000..482f6dfbdeba7
--- /dev/null
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Binary/Microsoft.CommonLanguageServerProtocol.Framework.Binary.csproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <!--
+    Defines a binary for VS insertion containing the clasp source.
+    This is a temporary project to ship the clasp binary in VS until partners (Razor and Webtools)
+    upgrade to the latest source-only version of the original clasp package.
+    
+    TODO, delete - https://github.com/dotnet/roslyn/issues/72251
+  -->
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <AssemblyName>Microsoft.CommonLanguageServerProtocol.Framework</AssemblyName>
+
+    <!-- Do not ship this as a nuget package - it is only needed for VS insertion. -->
+    <IsPackable>false</IsPackable>
+    <!-- Set visibility based on if this is a binary or just sources - https://github.com/dotnet/roslyn/issues/72251 -->
+    <DefineConstants>BINARY_COMPAT</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="StreamJsonRpc" />
+  </ItemGroup>
+  <Import Project="..\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems" Label="Shared" />
+
+</Project>
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleLanguageServer.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleLanguageServer.cs
index 5df8580127331..7a602999dfb3b 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleLanguageServer.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleLanguageServer.cs
@@ -10,7 +10,7 @@
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework.Example;
 
-public class ExampleLanguageServer : AbstractLanguageServer<ExampleRequestContext>
+internal class ExampleLanguageServer : AbstractLanguageServer<ExampleRequestContext>
 {
     private readonly Action<IServiceCollection>? _addExtraHandlers;
 
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleRequestContext.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleRequestContext.cs
index d1aab02c05235..9816f15f6deea 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleRequestContext.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleRequestContext.cs
@@ -4,7 +4,7 @@
 
 using Microsoft.CommonLanguageServerProtocol.Framework;
 
-public class ExampleRequestContext
+internal class ExampleRequestContext
 {
     public ILspServices LspServices;
     public ILspLogger Logger;
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/Microsoft.CommonLanguageServerProtocol.Framework.Example.csproj b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/Microsoft.CommonLanguageServerProtocol.Framework.Example.csproj
index b3bc1079ab409..723eee38c7883 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/Microsoft.CommonLanguageServerProtocol.Framework.Example.csproj
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/Microsoft.CommonLanguageServerProtocol.Framework.Example.csproj
@@ -14,7 +14,10 @@
   </ItemGroup>
   
   <ItemGroup Label="Project References">
-    <ProjectReference Include="..\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.csproj" />
     <ProjectReference Include="..\Protocol\Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj" />
   </ItemGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="Microsoft.CommonLanguageServerProtocol.Framework.UnitTests" />
+  </ItemGroup>
 </Project>
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/MultiRegisteringHandler.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/MultiRegisteringHandler.cs
index ce416b31a46fd..8a60594c16d6c 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/MultiRegisteringHandler.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/MultiRegisteringHandler.cs
@@ -8,7 +8,7 @@
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework.Example;
 
-public class MultiRegisteringHandler :
+internal class MultiRegisteringHandler :
     IRequestHandler<DidOpenTextDocumentParams, SemanticTokensDeltaPartialResult, ExampleRequestContext>,
     IRequestHandler<DidChangeTextDocumentParams, SemanticTokensDeltaPartialResult, ExampleRequestContext>,
     INotificationHandler<DidCloseTextDocumentParams, ExampleRequestContext>
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/NoOpLspLogger.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/NoOpLspLogger.cs
index 55e6a48e3eda1..f1a63b308094d 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/NoOpLspLogger.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/NoOpLspLogger.cs
@@ -6,7 +6,7 @@
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework.UnitTests;
 
-public sealed class NoOpLspLogger : AbstractLspLogger, ILspLogger
+internal sealed class NoOpLspLogger : AbstractLspLogger, ILspLogger
 {
     public static NoOpLspLogger Instance = new();
 
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestMethodHandlers.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestMethodHandlers.cs
index 8c046019107c2..59ef8bc6dfd71 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestMethodHandlers.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestMethodHandlers.cs
@@ -77,7 +77,7 @@ public Task HandleNotificationAsync(TestRequestContext requestContext, Cancellat
 }
 
 [LanguageServerEndpoint(Name, LanguageServerConstants.DefaultLanguageName)]
-public class MutatingHandler : IRequestHandler<int, string, TestRequestContext>
+internal class MutatingHandler : IRequestHandler<int, string, TestRequestContext>
 {
     public const string Name = "MutatingMethod";
     public static readonly IMethodHandler Instance = new MutatingHandler();
@@ -96,7 +96,7 @@ public Task<string> HandleRequestAsync(int request, TestRequestContext context,
 }
 
 [LanguageServerEndpoint(Name, LanguageServerConstants.DefaultLanguageName)]
-public class CompletingHandler : IRequestHandler<int, string, TestRequestContext>
+internal class CompletingHandler : IRequestHandler<int, string, TestRequestContext>
 {
     public const string Name = "CompletingMethod";
     public static readonly IMethodHandler Instance = new CompletingHandler();
@@ -118,7 +118,7 @@ public async Task<string> HandleRequestAsync(int request, TestRequestContext con
 }
 
 [LanguageServerEndpoint(Name, LanguageServerConstants.DefaultLanguageName)]
-public class CancellingHandler : IRequestHandler<int, string, TestRequestContext>
+internal class CancellingHandler : IRequestHandler<int, string, TestRequestContext>
 {
     public const string Name = "CancellingMethod";
     public static readonly IMethodHandler Instance = new CancellingHandler();
@@ -137,7 +137,7 @@ public async Task<string> HandleRequestAsync(int request, TestRequestContext con
 }
 
 [LanguageServerEndpoint(Name, LanguageServerConstants.DefaultLanguageName)]
-public class ThrowingHandler : IRequestHandler<int, string, TestRequestContext>
+internal class ThrowingHandler : IRequestHandler<int, string, TestRequestContext>
 {
     public const string Name = "ThrowingMethod";
     public static readonly IMethodHandler Instance = new ThrowingHandler();
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestRequestContext.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestRequestContext.cs
index 490a838c95fef..f0ea9646dfeca 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestRequestContext.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestRequestContext.cs
@@ -7,9 +7,9 @@
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework.UnitTests;
 
-public class TestRequestContext
+internal class TestRequestContext
 {
-    public class Factory : AbstractRequestContextFactory<TestRequestContext>
+    internal class Factory : AbstractRequestContextFactory<TestRequestContext>
     {
         public static readonly Factory Instance = new();
 
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractHandlerProvider.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractHandlerProvider.cs
index 8da74e6f69401..4af41c4bd96bc 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractHandlerProvider.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractHandlerProvider.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Collections.Immutable;
 
@@ -10,7 +13,11 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 /// <summary>
 /// Manages handler discovery and distribution.
 /// </summary>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public abstract class AbstractHandlerProvider
+#else
+internal abstract class AbstractHandlerProvider
+#endif
 {
     /// <summary>
     /// Gets the <see cref="RequestHandlerMetadata"/>s for all registered methods.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractLanguageServer.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractLanguageServer.cs
index ad8d5077fb960..4260996c47ff4 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractLanguageServer.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractLanguageServer.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Linq;
 using System.Reflection;
@@ -11,10 +14,16 @@
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public abstract class AbstractLanguageServer<TRequestContext>
+#else
+internal abstract class AbstractLanguageServer<TRequestContext>
+#endif
 {
     private readonly JsonRpc _jsonRpc;
+#pragma warning disable IDE1006 // Naming Styles - Required for API compat, TODO - https://github.com/dotnet/roslyn/issues/72251
     protected readonly ILspLogger _logger;
+#pragma warning restore IDE1006 // Naming Styles
 
     /// <summary>
     /// These are lazy to allow implementations to define custom variables that are used by
@@ -168,10 +177,10 @@ private sealed class DelegatingEntryPoint
         private readonly string _method;
         private readonly AbstractLanguageServer<TRequestContext> _target;
 
-        private static readonly MethodInfo s_entryPointMethod = typeof(DelegatingEntryPoint).GetMethod(nameof(EntryPointAsync));
-        private static readonly MethodInfo s_parameterlessEntryPointMethod = typeof(DelegatingEntryPoint).GetMethod(nameof(ParameterlessEntryPointAsync));
-        private static readonly MethodInfo s_notificationMethod = typeof(DelegatingEntryPoint).GetMethod(nameof(NotificationEntryPointAsync));
-        private static readonly MethodInfo s_parameterlessNotificationMethod = typeof(DelegatingEntryPoint).GetMethod(nameof(ParameterlessNotificationEntryPointAsync));
+        private static readonly MethodInfo s_entryPointMethod = typeof(DelegatingEntryPoint).GetMethod(nameof(EntryPointAsync))!;
+        private static readonly MethodInfo s_parameterlessEntryPointMethod = typeof(DelegatingEntryPoint).GetMethod(nameof(ParameterlessEntryPointAsync))!;
+        private static readonly MethodInfo s_notificationMethod = typeof(DelegatingEntryPoint).GetMethod(nameof(NotificationEntryPointAsync))!;
+        private static readonly MethodInfo s_parameterlessNotificationMethod = typeof(DelegatingEntryPoint).GetMethod(nameof(ParameterlessNotificationEntryPointAsync))!;
 
         public DelegatingEntryPoint(string method, AbstractLanguageServer<TRequestContext> target)
         {
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractLspLogger.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractLspLogger.cs
index 3193fc8282f81..41c4bf4001219 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractLspLogger.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractLspLogger.cs
@@ -2,11 +2,18 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public abstract class AbstractLspLogger : ILspLogger
+#else
+internal abstract class AbstractLspLogger : ILspLogger
+#endif
 {
     public abstract void LogDebug(string message, params object[] @params);
     public abstract void LogStartContext(string message, params object[] @params);
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractRequestContextFactory.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractRequestContextFactory.cs
index 3ec90ddbbf078..adcc85e1c484b 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractRequestContextFactory.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractRequestContextFactory.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -18,7 +21,11 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 /// </para>
 /// </summary>
 /// <typeparam name="TRequestContext">The type of the RequestContext to be used by the handler.</typeparam>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public abstract class AbstractRequestContextFactory<TRequestContext>
+#else
+internal abstract class AbstractRequestContextFactory<TRequestContext>
+#endif
 {
     /// <summary>
     /// Create a <typeparamref name="TRequestContext"/> object from the given <see cref="IQueueItem{RequestContextType}"/>.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractRequestScope.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractRequestScope.cs
index efd36dccd0e4b..7e5ea5c8aeb5a 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractRequestScope.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractRequestScope.cs
@@ -2,11 +2,18 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public abstract class AbstractRequestScope(string name) : IDisposable
+#else
+internal abstract class AbstractRequestScope(string name) : IDisposable
+#endif
 {
     public string Name { get; } = name;
 
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractTelemetryService.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractTelemetryService.cs
index cb60f7e6852f6..7df8edce2f545 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractTelemetryService.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/AbstractTelemetryService.cs
@@ -2,9 +2,16 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public abstract class AbstractTelemetryService
+#else
+internal abstract class AbstractTelemetryService
+#endif
 {
     public abstract AbstractRequestScope CreateRequestScope(string lspMethodName);
 }
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/BannedSymbols.txt b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/BannedSymbols.txt
new file mode 100644
index 0000000000000..42fd708fa29ec
--- /dev/null
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/BannedSymbols.txt
@@ -0,0 +1,73 @@
+T:Microsoft.VisualStudio.Shell.Interop.IComWrapper; Use Microsoft.VisualStudio.LanguageServices.Implementation.Interop.IComWrapperFixed instead
+T:Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions; Use CSharpFormattingOptions2 instead
+T:Microsoft.CodeAnalysis.Simplification.SimplificationOptions; Use SimplificationOptions2 instead
+T:Microsoft.CodeAnalysis.CodeStyle.CodeStyleOption`1; Use 'Microsoft.CodeAnalysis.CodeStyle.CodeStyleOption2' instead
+T:Microsoft.CodeAnalysis.CodeStyle.CodeStyleOptions; Use CodeStyleOptions2 instead
+T:Microsoft.CodeAnalysis.Recommendations;RecommendationOptions; Use RecommendationOptions2 instead
+T:Microsoft.CodeAnalysis.Formatting.FormattingOptions; Use FormattingOptions2 instead
+T:Microsoft.CodeAnalysis.Options.PerLanguageOption`1; Use PerLanguageOption2<T> instead
+T:Microsoft.CodeAnalysis.Options.Option`1; Use 'Microsoft.CodeAnalysis.Options.Option2' instead
+T:Microsoft.CodeAnalysis.SyntaxWalker; Use SyntaxNode.DescendantNodes methods instead.
+P:Microsoft.CodeAnalysis.Completion.CompletionContext.Options; Use CompletionOptions instead.
+P:Microsoft.CodeAnalysis.Completion.CompletionItem.Properties; Use GetProperties instead.
+M:Microsoft.CodeAnalysis.Completion.CompletionItem.WithProperties(System.Collections.Immutable.ImmutableDictionary{System.String,System.String}); Use ImmutableArray overload instead.
+P:Microsoft.CodeAnalysis.Completion.CompletionList.Items; Use CompletionList.ItemsList instead
+M:Microsoft.CodeAnalysis.Completion.CompletionProvider.ShouldTriggerCompletion(Microsoft.CodeAnalysis.Text.SourceText,System.Int32,Microsoft.CodeAnalysis.Completion.CompletionTrigger,Microsoft.CodeAnalysis.Options.OptionSet); Use internal overload instead
+M:Microsoft.CodeAnalysis.Completion.CompletionProvider.GetDescriptionAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Completion.CompletionItem,System.Threading.CancellationToken); Use internal overload instead
+M:Microsoft.CodeAnalysis.Completion.CompletionService.FilterItems(Microsoft.CodeAnalysis.Document,System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.Completion.CompletionItem},System.String); Use internal overload instead
+M:Microsoft.CodeAnalysis.Completion.CompletionService.GetCompletionsAsync(Microsoft.CodeAnalysis.Document,System.Int32,Microsoft.CodeAnalysis.Completion.CompletionTrigger,System.Collections.Immutable.ImmutableHashSet{System.String},Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use internal overload instead
+M:Microsoft.CodeAnalysis.Completion.CompletionService.GetDescriptionAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Completion.CompletionItem,System.Threading.CancellationToken); Use internal overload instead
+M:Microsoft.CodeAnalysis.Completion.CompletionService.GetRules; Use internal overload instead
+M:Microsoft.CodeAnalysis.QuickInfo.QuickInfoService.GetQuickInfoAsync(Microsoft.CodeAnalysis.Document,System.Int32,System.Threading.CancellationToken); Use internal overload instead
+M:Microsoft.CodeAnalysis.CodeFixes.FixAllContext.#ctor(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider,Microsoft.CodeAnalysis.CodeFixes.FixAllScope,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.CodeFixes.FixAllContext.DiagnosticProvider,System.Threading.CancellationToken); Use internal overload instead
+M:Microsoft.CodeAnalysis.CodeFixes.FixAllContext.#ctor(Microsoft.CodeAnalysis.Document,System.Nullable{Microsoft.CodeAnalysis.Text.TextSpan},Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider,Microsoft.CodeAnalysis.CodeFixes.FixAllScope,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.CodeFixes.FixAllContext.DiagnosticProvider,System.Threading.CancellationToken); Use internal overload instead
+M:Microsoft.CodeAnalysis.CodeFixes.FixAllContext.#ctor(Microsoft.CodeAnalysis.Project,Microsoft.CodeAnalysis.CodeFixes.CodeFixProvider,Microsoft.CodeAnalysis.CodeFixes.FixAllScope,System.String,System.Collections.Generic.IEnumerable{System.String},Microsoft.CodeAnalysis.CodeFixes.FixAllContext.DiagnosticProvider,System.Threading.CancellationToken); Use internal overload instead
+M:Microsoft.CodeAnalysis.Document.GetOptionsAsync(System.Threading.CancellationToken); Use Document.GetAnalyzerConfigOptionsAsync instead
+T:Microsoft.CodeAnalysis.Options.DocumentOptionSet; Use AnalyzerConfigOptions instead
+M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetService``2(System.IServiceProvider); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing.
+M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetService``2(System.IServiceProvider,System.Boolean); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
+M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetServiceAsync``2(Microsoft.VisualStudio.Shell.IAsyncServiceProvider); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
+M:Microsoft.VisualStudio.Shell.ServiceExtensions.GetServiceAsync``2(Microsoft.VisualStudio.Shell.IAsyncServiceProvider,System.Boolean); Use RoslynServiceExtensions instead. This extension internally relies on ThreadHelper, which is incompatible with testing
+P:Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory; Use IThreadingContext.JoinableTaskFactory instead.
+M:Microsoft.CodeAnalysis.Formatting.Formatter.FormatAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use internal overload instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.FormatAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.FormatAsync(Microsoft.CodeAnalysis.Document,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextSpan},Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.FormatAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.Format(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.Workspace,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.Format(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.Workspace,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.Format(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Workspace,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.Format(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextSpan},Microsoft.CodeAnalysis.Workspace,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.GetFormattedTextChanges(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.Workspace,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.GetFormattedTextChanges(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Workspace,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.GetFormattedTextChanges(Microsoft.CodeAnalysis.SyntaxNode,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextSpan},Microsoft.CodeAnalysis.Workspace,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload with SyntaxFormattingOptions instead
+M:Microsoft.CodeAnalysis.Formatting.Formatter.OrganizeImportsAsync(Microsoft.CodeAnalysis.Document,System.Threading.CancellationToken); Call IOrganizeImportsService.OrganizeImportsAsync directly
+M:Microsoft.CodeAnalysis.Simplification.Simplifier.ReduceAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload that takes SimplifierOptions
+M:Microsoft.CodeAnalysis.Simplification.Simplifier.ReduceAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.SyntaxAnnotation,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload that takes SimplifierOptions
+M:Microsoft.CodeAnalysis.Simplification.Simplifier.ReduceAsync(Microsoft.CodeAnalysis.Document,Microsoft.CodeAnalysis.Text.TextSpan,Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload that takes SimplifierOptions
+M:Microsoft.CodeAnalysis.Simplification.Simplifier.ReduceAsync(Microsoft.CodeAnalysis.Document,System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.Text.TextSpan},Microsoft.CodeAnalysis.Options.OptionSet,System.Threading.CancellationToken); Use overload that takes SimplifierOptions
+M:Microsoft.CodeAnalysis.Editing.SyntaxEditor.#ctor(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.Host.HostWorkspaceServices); Use overload that takes HostSolutionServices instead
+M:Microsoft.CodeAnalysis.FileTextLoader.#ctor(System.String,System.Text.Encoding); use WorkspaceFileTextLoader that calls on ITextFactoryService to create SourceText
+M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.SyntaxTree(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding); Use CSharpSyntaxTree sublass that takes checksum algorithm
+M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken); Use CSharpSyntaxTree sublass that takes checksum algorithm
+M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.CreateWithoutClone(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode); Use CSharpSyntaxTree sublass that takes checksum algorithm
+M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.Create(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxNode, Microsoft.CodeAnalysis.CSharp.CSharpParseOptions options, System.String path, System.Text.Encoding encoding); Use CSharpSyntaxTree sublass that takes checksum algorithm
+M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken); Use API that takes SourceText
+M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken); Use API that takes SourceText
+M:Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.SyntaxTree(Microsoft.CodeAnalysis.SyntaxNode,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding); Use VisualBasicSyntaxTree sublass that takes checksum algorithm
+M:Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Threading.CancellationToken); Use overload with SourceText
+M:Microsoft.CodeAnalysis.VisualBasic.SyntaxFactory.ParseSyntaxTree(System.String,Microsoft.CodeAnalysis.ParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken); Use overload with SourceText
+M:Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.CreateWithoutClone(Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxNode); Use VisualBasicSyntaxTree sublass that takes checksum algorithm
+M:Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.Create(Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxNode,Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic}); Use VisualBasicSyntaxTree sublass that takes checksum algorithm
+M:Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.Create(Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxNode,Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions,System.String,System.Text.Encoding); Use VisualBasicSyntaxTree sublass that takes checksum algorithm
+M:Microsoft.CodeAnalysis.VisualBasic.VisualBasicSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Threading.CancellationToken); Use overload with SourceText
+M:Microsoft.CodeAnalysis.Workspaces.Workspace.SetCurrentSolution(Microsoft.CodeAnalysis.Solution); Use SetCurrentSolutionEx instead.
+M:System.Enum.GetHashCode(); Cast to integral type to avoid boxing on .NET Framework
+M:Microsoft.CodeAnalysis.CodeActions.CodeAction.PostProcessAsync(System.Collections.Generic.IEnumerable{Microsoft.CodeAnalysis.CodeActions.CodeActionOperation},System.Threading.CancellationToken); Use overload that takes a solution
+M:Microsoft.CodeAnalysis.CodeActions.CodeAction.PostProcessChangesAsync(Microsoft.CodeAnalysis.Solution,System.Threading.CancellationToken); Use overload that takes a solution
+M:Microsoft.CodeAnalysis.CodeActions.CodeActionWithOptions.GetOperationsAsync(System.Object,System.Threading.CancellationToken); Use overload that takes a solution
+M:Microsoft.CodeAnalysis.CodeActions.CodeAction.GetOperationsAsync(System.Threading.CancellationToken); Use overload that takes a solution
+M:Microsoft.CodeAnalysis.CodeActions.CodeAction.GetPreviewOperationsAsync(System.Threading.CancellationToken); Use overload that takes a solution
+M:Microsoft.CodeAnalysis.CodeActions.CodeAction.ComputeOperationsAsync(System.Threading.CancellationToken); Use overload that takes progress
+M:Microsoft.CodeAnalysis.CodeActions.CodeAction.GetChangedSolutionAsync(CSystem.Threading.CancellationToken); Use overload that takes progress
+M:Microsoft.CodeAnalysis.CodeActions.CodeAction.GetChangedDocumentAsync(CancellationToken); Use overload that takes progress
+M:System.Diagnostics.Tracing.EventSource.WriteEvent(System.Int32,System.Object[]); Use WriteEventCore instead
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/BreakingChanges.md b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/BreakingChanges.md
deleted file mode 100644
index 9ac6b0f33978c..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/BreakingChanges.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# Handling breaking changes in CLaSP
-
-## How Versions will be handled
-
-We'll try to stick to SemVer, so breaking changes should result in an increase of the Major version. When there is an increase of the major version we will include both the previous and new version of the dll in the CLaSP VSIX for a time, during which partner teams will be expected to upgrade (to make sure we're only shipping usages of one of the dll's in VS). This might look like:
-
-```text
-\CLaSP.vsix
-  \5.x.x
-    \Microsoft.CommonLanguageServerProtocol.Framework.dll (version 5.something)
-  \6.x.x
-    \Microsoft.CommonLanguageServerProtocol.Framework.dll (version 6.something)
-```
-
-During this time we'll have Binding redirects for any 5.x.x and below to the shipped 5.x.x version, and 6.0.0 and higher will redirect to 6.x.x.
-
-Once we have migrated all partners to the new version (or after warning and some time has passed) we will remove the old version from the VSIX (and it's accompanying redirect) leaving the shape as something like
-
-```text
-\CLaSP.vsix
-  \6.x.x
-    \Microsoft.CommonLanguageServerProtocol.Framework.dll (version 6.something)
-```
-
-This is the model used by the `Microsoft.VisualStudio.LanguageServer.Protocol` package and they say they've had great success with this method.
-
-## Which changes will result in what update types
-
-When in doubt refer back to <https://github.com/dotnet/runtime/blob/main/docs/coding-guidelines/breaking-change-rules.md>.
-
-|Change Type|Agreed Version update type|
-|---|---|
-|Addition of Class/Interface/etc|Minor|
-|Removal of Class/interface/etc|Major|
-|Addition/Removal of Member to Interface/Abstract|Major|
-|New dependency if exposed|Major|
-|New dependency if hidden|Minor?|
-|Dependency version change if exposed|Major|
-|Dependency version if upgrade is major|Major|
-|Dep... not exposed|Minor|
-|Change of Method signature|Major|
-|Implementation changed|Patch (unless it has big effect on output)|
-
-Keep a log of breaking changes (a PR label may be ideal here).
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/HandlerProvider.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/HandlerProvider.cs
index c31ab803225f5..ac0e0bd0ad03b 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/HandlerProvider.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/HandlerProvider.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializeHandler.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializeHandler.cs
index 820e5284d9d4b..aeb2a3d698f06 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializeHandler.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializeHandler.cs
@@ -2,13 +2,20 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework.Handlers;
 
 [LanguageServerEndpoint("initialize", LanguageServerConstants.DefaultLanguageName)]
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public class InitializeHandler<TRequest, TResponse, TRequestContext>
+#else
+internal class InitializeHandler<TRequest, TResponse, TRequestContext>
+#endif
     : IRequestHandler<TRequest, TResponse, TRequestContext>
 {
     private readonly IInitializeManager<TRequest, TResponse> _capabilitiesManager;
@@ -20,8 +27,6 @@ public InitializeHandler(IInitializeManager<TRequest, TResponse> capabilitiesMan
 
     public bool MutatesSolutionState => true;
 
-    public bool RequiresLSPSolution => false;
-
     public Task<TResponse> HandleRequestAsync(TRequest request, TRequestContext context, CancellationToken cancellationToken)
     {
         _capabilitiesManager.SetInitializeParams(request);
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializedHandler.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializedHandler.cs
index 0c58b45c19ecd..46f87a4c52df4 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializedHandler.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializedHandler.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,14 +12,16 @@
 namespace Microsoft.CommonLanguageServerProtocol.Framework.Handlers;
 
 [LanguageServerEndpoint("initialized", LanguageServerConstants.DefaultLanguageName)]
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public class InitializedHandler<TRequest, TRequestContext> : INotificationHandler<TRequest, TRequestContext>
+#else
+internal class InitializedHandler<TRequest, TRequestContext> : INotificationHandler<TRequest, TRequestContext>
+#endif
 {
     private bool HasBeenInitialized = false;
 
     public bool MutatesSolutionState => true;
 
-    public bool RequiresLSPSolution => true;
-
     public Task HandleNotificationAsync(TRequest request, TRequestContext requestContext, CancellationToken cancellationToken)
     {
         if (HasBeenInitialized)
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IHandlerProvider.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IHandlerProvider.cs
index b93fae9685c29..837cd4b051de5 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IHandlerProvider.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IHandlerProvider.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Collections.Immutable;
 
@@ -10,7 +13,11 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 /// <summary>
 /// Manages handler discovery and distribution.
 /// </summary>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface IHandlerProvider
+#else
+internal interface IHandlerProvider
+#endif
 {
     ImmutableArray<RequestHandlerMetadata> GetRegisteredMethods();
 
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IInitializeManager.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IInitializeManager.cs
index 2bddb76a55ef5..13e9fc9293a3e 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IInitializeManager.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IInitializeManager.cs
@@ -2,9 +2,16 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface IInitializeManager<TRequest, TResponse>
+#else
+internal interface IInitializeManager<TRequest, TResponse>
+#endif
 {
     /// <summary>
     /// Gets a response to be used for "initialize", completing the negoticaitons between client and server.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILifeCycleManager.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILifeCycleManager.cs
index 4f657579a7e7a..73b17b89df6ad 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILifeCycleManager.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILifeCycleManager.cs
@@ -2,7 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System.Threading.Tasks;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
@@ -11,7 +13,11 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 /// An optional component to run additional logic when LSP shutdown and exit are called,
 /// for example logging messages, cleaning up custom resources, etc.
 /// </summary>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface ILifeCycleManager
+#else
+internal interface ILifeCycleManager
+#endif
 {
     /// <summary>
     /// Called when the server recieves the LSP exit notification.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILspLogger.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILspLogger.cs
index 930ce4c6d939f..3bfe075fc3e0e 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILspLogger.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILspLogger.cs
@@ -2,11 +2,18 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface ILspLogger
+#else
+internal interface ILspLogger
+#endif
 {
     void LogStartContext(string message, params object[] @params);
     void LogEndContext(string message, params object[] @params);
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILspServices.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILspServices.cs
index 99febdc229d96..14ed351fb7e7c 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILspServices.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ILspServices.cs
@@ -2,14 +2,20 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface ILspServices : IDisposable
+#else
+internal interface ILspServices : IDisposable
+#endif
 {
     T GetRequiredService<T>() where T : notnull;
 
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IMethodHandler.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IMethodHandler.cs
index fab7b6af7935c..d8299e27250a1 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IMethodHandler.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IMethodHandler.cs
@@ -2,12 +2,19 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
 /// <summary>
 /// Top level type for LSP request handler.
 /// </summary>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface IMethodHandler
+#else
+internal interface IMethodHandler
+#endif
 {
     /// <summary>
     /// Whether or not the solution state on the server is modified as a part of handling this request.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/INotificationHandler.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/INotificationHandler.cs
index ab20dc4500c44..22c8d8f2c38a1 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/INotificationHandler.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/INotificationHandler.cs
@@ -5,13 +5,20 @@
 using System.Threading;
 using System.Threading.Tasks;
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
 /// <summary>
 /// An interface for handlers of methods which do not return a response and receive no parameters.
 /// </summary>
 /// <typeparam name="TRequestContext">The type of the RequestContext to be used by this handler.</typeparam>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface INotificationHandler<TRequestContext> : IMethodHandler
+#else
+internal interface INotificationHandler<TRequestContext> : IMethodHandler
+#endif
 {
     Task HandleNotificationAsync(TRequestContext requestContext, CancellationToken cancellationToken);
 }
@@ -21,7 +28,11 @@ public interface INotificationHandler<TRequestContext> : IMethodHandler
 /// </summary>
 /// <typeparam name="TRequest">The type of the Request parameter to be received.</typeparam>
 /// <typeparam name="TRequestContext">The type of the RequestContext to be used by this handler.</typeparam>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface INotificationHandler<TRequest, TRequestContext> : IMethodHandler
+#else
+internal interface INotificationHandler<TRequest, TRequestContext> : IMethodHandler
+#endif
 {
     Task HandleNotificationAsync(TRequest request, TRequestContext requestContext, CancellationToken cancellationToken);
 }
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IQueueItem.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IQueueItem.cs
index 51cf9a95f240b..832bbf4fdeae2 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IQueueItem.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IQueueItem.cs
@@ -6,13 +6,20 @@
 using System.Threading;
 using System.Threading.Tasks;
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
 /// <summary>
 /// An item to be queued for execution.
 /// </summary>
 /// <typeparam name="TRequestContext">The type of the request context to be passed along to the handler.</typeparam>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface IQueueItem<TRequestContext>
+#else
+internal interface IQueueItem<TRequestContext>
+#endif
 {
     /// <summary>
     /// Executes the work specified by this queue item.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestContextFactory.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestContextFactory.cs
index c7d7898b8f03e..ee07e97cfdc0a 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestContextFactory.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestContextFactory.cs
@@ -6,6 +6,9 @@
 using System.Threading;
 using System.Threading.Tasks;
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
 /// <summary>
@@ -20,7 +23,11 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 /// </summary>
 /// <typeparam name="TRequestContext">The type of the RequestContext to be used by the handler.</typeparam>
 [Obsolete($"Use {nameof(AbstractRequestContextFactory<TRequestContext>)} instead.", error: false)]
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface IRequestContextFactory<TRequestContext>
+#else
+internal interface IRequestContextFactory<TRequestContext>
+#endif
 {
     /// <summary>
     /// Create a <typeparamref name="TRequestContext"/> object from the given <see cref="IQueueItem{RequestContextType}"/>.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestExecutionQueue.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestExecutionQueue.cs
index 5f36c4e8477b3..bae2a3c7ff1e8 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestExecutionQueue.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestExecutionQueue.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Threading;
 using System.Threading.Tasks;
@@ -12,7 +15,11 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 /// Queues requests to be executed in the proper order.
 /// </summary>
 /// <typeparam name="TRequestContext">The type of the RequestContext to be used by the handler.</typeparam>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface IRequestExecutionQueue<TRequestContext> : IAsyncDisposable
+#else
+internal interface IRequestExecutionQueue<TRequestContext> : IAsyncDisposable
+#endif
 {
     /// <summary>
     /// Queue a request.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestHandler.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestHandler.cs
index cbdff1e945242..2bc711aabe3a2 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestHandler.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/IRequestHandler.cs
@@ -2,14 +2,19 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.CommonLanguageServerProtocol.Framework;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface IRequestHandler<TRequest, TResponse, TRequestContext> : IMethodHandler
+#else
+internal interface IRequestHandler<TRequest, TResponse, TRequestContext> : IMethodHandler
+#endif
 {
     /// <summary>
     /// Handles an LSP request in the context of the supplied document and/or solution.
@@ -21,7 +26,11 @@ public interface IRequestHandler<TRequest, TResponse, TRequestContext> : IMethod
     Task<TResponse> HandleRequestAsync(TRequest request, TRequestContext context, CancellationToken cancellationToken);
 }
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface IRequestHandler<TResponse, TRequestContext> : IMethodHandler
+#else
+internal interface IRequestHandler<TResponse, TRequestContext> : IMethodHandler
+#endif
 {
     /// <summary>
     /// Handles an LSP request in the context of the supplied document and/or solution.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ITextDocumentIdentifierHandler.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ITextDocumentIdentifierHandler.cs
index 542bb422576a4..eaf30967bc0b9 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ITextDocumentIdentifierHandler.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/ITextDocumentIdentifierHandler.cs
@@ -2,9 +2,16 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface ITextDocumentIdentifierHandler<TRequest, TTextDocumentIdentifier> : ITextDocumentIdentifierHandler
+#else
+internal interface ITextDocumentIdentifierHandler<TRequest, TTextDocumentIdentifier> : ITextDocumentIdentifierHandler
+#endif
 {
     /// <summary>
     /// Gets the identifier of the document from the request, if the request provides one.
@@ -12,6 +19,10 @@ public interface ITextDocumentIdentifierHandler<TRequest, TTextDocumentIdentifie
     TTextDocumentIdentifier GetTextDocumentIdentifier(TRequest request);
 }
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public interface ITextDocumentIdentifierHandler
+#else
+internal interface ITextDocumentIdentifierHandler
+#endif
 {
 }
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/LanguageServerConstants.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/LanguageServerConstants.cs
index 556e176ac896c..90518fec07d1b 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/LanguageServerConstants.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/LanguageServerConstants.cs
@@ -2,9 +2,16 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public class LanguageServerConstants
+#else
+internal class LanguageServerConstants
+#endif
 {
     /// <summary>
     /// Default language name for use with <see cref="LanguageServerEndpointAttribute"/> and <see cref="AbstractHandlerProvider.GetMethodHandler"/>.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/LanguageServerEndpointAttribute.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/LanguageServerEndpointAttribute.cs
index db159f41e5403..1f8c71ce2d7ab 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/LanguageServerEndpointAttribute.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/LanguageServerEndpointAttribute.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Linq;
 
@@ -11,7 +14,11 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 /// An attribute which identifies the method which an <see cref="IMethodHandler"/> implements.
 /// </summary>
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Method, AllowMultiple = false)]
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public class LanguageServerEndpointAttribute : Attribute
+#else
+internal class LanguageServerEndpointAttribute : Attribute
+#endif
 {
     /// <summary>
     /// Contains the method that this <see cref="IMethodHandler"/> implements.
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Package.csproj b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Package.csproj
new file mode 100644
index 0000000000000..5fc44385be687
--- /dev/null
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Package.csproj
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Licensed to the .NET Foundation under one or more agreements. The .NET Foundation licenses this file to you under the MIT license. See the LICENSE file in the project root for more information. -->
+
+<!--
+  Defines a source-only package for the Microsoft.CommonLanguageServerProtocol.Framework sources.
+-->
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+    <TargetFramework>netstandard2.0</TargetFramework>
+
+    <!-- NuGet -->
+    <IsPackable>true</IsPackable>
+    <IsSourcePackage>true</IsSourcePackage>
+    <PackageId>Microsoft.CommonLanguageServerProtocol.Framework</PackageId>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <PackageDescription>
+      A framework of sources for building Language Server Protocol implementations in C#.
+    </PackageDescription>
+    <!-- Remove once https://github.com/NuGet/Home/issues/8583 is fixed -->
+    <NoWarn>$(NoWarn);NU5128</NoWarn>
+    <!-- Required to avoid NuGet ignoring the .editorconfig file -->
+    <NoDefaultExcludes>true</NoDefaultExcludes>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="StreamJsonRpc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Utilities\IsExternalInit.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="contentFiles\.editorconfig" />
+  </ItemGroup>
+  
+  <!--
+    Includes the .editorconfig file in the package at the contentFiles root.
+    This ensures analyzers do not run against source content from the nuget package.
+  -->
+  <ItemGroup>
+    <Content Include="contentFiles\.editorconfig">
+      <Pack>true</Pack>
+      <PackagePath>contentFiles\cs\$(TargetFramework)\</PackagePath>
+    </Content>
+  </ItemGroup>
+</Project>
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems
new file mode 100644
index 0000000000000..3e94a73112030
--- /dev/null
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <MSBuildAllProjects Condition="'$(MSBuildVersion)' == '' Or '$(MSBuildVersion)' &lt; '16.0'">$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <SharedGUID>64eaded3-4b5d-4431-bbe5-a4aba1c38c00</SharedGUID>
+  </PropertyGroup>
+  <PropertyGroup Label="Configuration">
+    <Import_RootNamespace>Microsoft.CommonLanguageServerProtocol.Framework.Shared</Import_RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="$(MSBuildThisFileDirectory)AbstractHandlerProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)AbstractLanguageServer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)AbstractLspLogger.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)AbstractRequestContextFactory.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)AbstractRequestScope.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)AbstractTelemetryService.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)HandlerProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Handlers\InitializedHandler.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Handlers\InitializeHandler.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IHandlerProvider.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IInitializeManager.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ILifeCycleManager.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ILspLogger.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ILspServices.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IMethodHandler.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)INotificationHandler.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IQueueItem.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IRequestContextFactory.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IRequestExecutionQueue.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IRequestHandler.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ITextDocumentIdentifierHandler.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)LanguageServerConstants.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)LanguageServerEndpointAttribute.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)QueueItem.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)RequestExecutionQueue.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)RequestHandlerMetadata.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)RequestShutdownEventArgs.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)WrappedHandlerProvider.cs" />
+    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Utilities\IsExternalInit.cs" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Shared.shproj b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Shared.shproj
new file mode 100644
index 0000000000000..cc3aae4558d86
--- /dev/null
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.Shared.shproj
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>64eaded3-4b5d-4431-bbe5-a4aba1c38c00</ProjectGuid>
+    <MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
+  </PropertyGroup>
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.Default.props" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.Common.props" />
+  <PropertyGroup />
+  <Import Project="Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems" Label="Shared" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\CodeSharing\Microsoft.CodeSharing.CSharp.targets" />
+  <ItemGroup>
+    <AdditionalFiles Remove="BannedSymbols.txt" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.csproj b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.csproj
deleted file mode 100644
index 4e6abaa06ddaf..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Microsoft.CommonLanguageServerProtocol.Framework.csproj
+++ /dev/null
@@ -1,24 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Licensed to the .NET Foundation under one or more agreements. The .NET Foundation licenses this file to you under the MIT license. See the LICENSE file in the project root for more information. -->
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Library</OutputType>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <IsPackable>true</IsPackable>
-    <PackageDescription>
-      A framework for building Language Server Protocol implementations in C#.
-    </PackageDescription>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Utilities\IsExternalInit.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="StreamJsonRpc" />
-  </ItemGroup>
-  <ItemGroup>
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities" />
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests" />
-    <InternalsVisibleTo Include="Microsoft.CommonLanguageServerProtocol.Framework.UnitTests" />
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.Razor.UnitTests" />
-  </ItemGroup>
-</Project>
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/QueueItem.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/QueueItem.cs
index fce873b6c73d7..5cf8e93cc2383 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/QueueItem.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/QueueItem.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Linq;
 using System.Threading;
@@ -113,6 +116,8 @@ public async Task<TRequestContext> CreateRequestContextAsync(IMethodHandler hand
     /// representing the task that the client is waiting for, then re-thrown so that
     /// the queue can correctly handle them depending on the type of request.
     /// </summary>
+    /// <param name="context">Context used for the request.</param>
+    /// <param name="handler">The handler to execute.</param>
     /// <param name="cancellationToken"></param>
     /// <returns>The result of the request.</returns>
     public async Task StartRequestAsync(TRequestContext? context, IMethodHandler handler, CancellationToken cancellationToken)
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestExecutionQueue.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestExecutionQueue.cs
index 3f982243d2aad..ad65a6f58fbd5 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestExecutionQueue.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestExecutionQueue.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
@@ -46,7 +49,11 @@ namespace Microsoft.CommonLanguageServerProtocol.Framework;
 /// more messages, and a new queue will need to be created.
 /// </para>
 /// </remarks>
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public class RequestExecutionQueue<TRequestContext> : IRequestExecutionQueue<TRequestContext>
+#else
+internal class RequestExecutionQueue<TRequestContext> : IRequestExecutionQueue<TRequestContext>
+#endif
 {
     protected readonly ILspLogger _logger;
     protected readonly AbstractHandlerProvider _handlerProvider;
@@ -112,6 +119,7 @@ public void Start()
     /// </summary>
     /// <param name="request">The request to handle.</param>
     /// <param name="methodName">The name of the LSP method.</param>
+    /// <param name="lspServices">The set of LSP services to use.</param>
     /// <param name="requestCancellationToken">A cancellation token that will cancel the handing of this request.
     /// The request could also be cancelled by the queue shutting down.</param>
     /// <returns>A task that can be awaited to observe the results of the handing of this request.</returns>
@@ -311,6 +319,7 @@ protected virtual IMethodHandler GetHandlerForRequest(IQueueItem<TRequestContext
     /// which would otherwise be lost to the fire-and-forget task in the queue.
     /// </summary>
     /// <param name="nonMutatingRequestTask">The task to be inspected.</param>
+    /// <param name="rethrowExceptions">If exceptions should be re-thrown.</param>
     /// <returns>The task from <paramref name="nonMutatingRequestTask"/>, to allow chained calls if needed.</returns>
     public virtual Task WrapStartRequestTaskAsync(Task nonMutatingRequestTask, bool rethrowExceptions)
     {
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestHandlerMetadata.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestHandlerMetadata.cs
index 94af09271f6bc..a4e41c02d182b 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestHandlerMetadata.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestHandlerMetadata.cs
@@ -2,8 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public record RequestHandlerMetadata(string MethodName, Type? RequestType, Type? ResponseType, string Language);
+#else
+internal record RequestHandlerMetadata(string MethodName, Type? RequestType, Type? ResponseType, string Language);
+#endif
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestShutdownEventArgs.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestShutdownEventArgs.cs
index ce7a816dfe9f4..e689d852425f1 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestShutdownEventArgs.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/RequestShutdownEventArgs.cs
@@ -2,11 +2,18 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 
 namespace Microsoft.CommonLanguageServerProtocol.Framework;
 
+#if BINARY_COMPAT // TODO - Remove with https://github.com/dotnet/roslyn/issues/72251
 public class RequestShutdownEventArgs : EventArgs
+#else
+internal class RequestShutdownEventArgs : EventArgs
+#endif
 {
     public string Message { get; }
 
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/WrappedHandlerProvider.cs b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/WrappedHandlerProvider.cs
index 7ffc525c5539b..120b54dfb0c21 100644
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/WrappedHandlerProvider.cs
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/WrappedHandlerProvider.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+// This is consumed as 'generated' code in a source package and therefore requires an explicit nullable enable
+#nullable enable
+
 using System;
 using System.Collections.Immutable;
 
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/contentFiles/.editorconfig b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/contentFiles/.editorconfig
new file mode 100644
index 0000000000000..3bd53642047ae
--- /dev/null
+++ b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/contentFiles/.editorconfig
@@ -0,0 +1,10 @@
+# Remove the line below if you want to inherit .editorconfig settings from higher directories
+root = true
+
+# C# files
+[*.cs]
+
+# We don't want any analyzer diagnostics to be reported for people consuming this as a source package.
+dotnet_analyzer_diagnostic.severity = none
+
+generated_code = true
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.cs.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.cs.xlf
deleted file mode 100644
index 79b5f25b69e1d..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.cs.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="cs" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">Nejde deserializovat identifikátor Uri. Zjistila se neočekávaná hodnota: {0}.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">Nejde deserializovat MarkupContent. Zjistila se neočekávaná hodnota: {0}.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">Typ SumType nemůže mít jako parametr typu jiný typ SumType.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">Žádný z parametrů typu SumType nelze deserializovat.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">U typu {0} chybí konstruktor, který jako parametr přebírá jeden řetězec.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">Nedá se deserializovat výčet založený na řetězci. Zjistila se neočekávaná data: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">Nejde deserializovat TextDocumentSyncOptions. Zjistila se neočekávaná hodnota: {0}.</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.de.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.de.xlf
deleted file mode 100644
index 8f9ddabcc3a44..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.de.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="de" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">URI kann nicht deserialisiert werden kann. Unerwarteter Wert erkannt: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">MarkupContent kann nicht deserialisiert werden. Unerwarteter Wert erkannt: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">Ein „SumType“ kann keinen anderen „SumType“ als Typparameter aufweisen.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">Keiner der Parameter vom Typ „SumType“ konnte deserialisiert werden</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">Für den Typ {0} fehlt ein Konstruktor, der eine einzelne Zeichenfolge als Parameter akzeptiert.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">Die zeichenfolgenbasierte Enumeration kann nicht deserialisiert werden. Unerwartete Daten: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">TextDocumentSyncOptions kann nicht deserialisiert werden. Unerwarteter Wert erkannt: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.es.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.es.xlf
deleted file mode 100644
index f453befd9ca20..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.es.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="es" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">No se puede deserializar el URI. Se encontró un valor inesperado: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">No se puede deserializar MarkupContent. Se encontró un valor inesperado: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">Un SumType no puede tener otro SumType como parámetro de tipo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">No se pudo deserializar ninguno de los parámetros de tipo SumType</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">Al tipo {0} le falta un contructor que toma una sola cadena como parámetro.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">No se puede deserializar la enumeración basada en cadenas. Se encontraron datos inesperados: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">No se puede deserializar TextDocumentSyncOptions. Se encontró un valor inesperado: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.fr.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.fr.xlf
deleted file mode 100644
index 5e7e2defcd43f..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.fr.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="fr" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">Impossible de désérialiser l'URI. Valeur inattendue rencontrée : {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">Impossible de désérialiser MarkupContent. Valeur inattendue rencontrée : {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">Un SumType ne peut pas avoir un autre SumType comme paramètre de type.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">Aucun des paramètres de type SumType n’a pu être désérialisé.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">Il manque un constructeur de type {0} qui accepte une seule chaîne comme paramètre.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">Impossible de désérialiser l’énumération basée sur une chaîne. Données inattendues rencontrées : {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">Impossible de désérialiser TextDocumentSyncOptions. Valeur inattendue rencontrée : {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.it.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.it.xlf
deleted file mode 100644
index 379ebf409cd07..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.it.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="it" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">Non è possibile deserializzare Uri. È stato rilevato il valore imprevisto {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">Non è possibile deserializzare MarkupContent. È stato rilevato il valore imprevisto {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">Un SumType non può avere un altro SumType come parametro di tipo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">Nessuno dei parametri di tipo SumType può essere deserializzato</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">Nel tipo {0} manca un costruttore che accetta una singola stringa come parametro.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">Impossibile deserializzare l'enumerazione basata su stringhe. Rilevati dati imprevisti: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">Non è possibile deserializzare TextDocumentSyncOptions. È stato rilevato il valore imprevisto {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ja.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ja.xlf
deleted file mode 100644
index 6e4c76df587e6..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ja.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ja" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">URI を逆シリアル化できません。予期しない値が発生しました: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">MarkupContent を逆シリアル化できません。予期しない値が発生しました: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">SumType に型パラメーターとして別の SumType を指定することはできません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">どの SumType 型パラメーターも逆シリアル化できませんでした</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">パラメーターとして単一の文字列を取るコントラクターが 型 {0} にありません。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">文字列ベースの列挙型を逆シリアル化できません。予期しないデータが検出されました: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">TextDocumentSyncOptions を逆シリアル化できません。予期しない値が発生しました: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ko.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ko.xlf
deleted file mode 100644
index fe6d6b15e95b6..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ko.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ko" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">URI를 역직렬화할 수 없습니다. 예기치 않은 값 {0}이(가) 있습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">MarkupContent를 역직렬화할 수 없습니다. 예기치 않은 값 {0}이(가) 있습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">SumType에는 다른 SumType을 형식 매개 변수로 사용할 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">SumType 형식 매개 변수를 역직렬화할 수 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">{0} 유형에 단일 문자열을 매개 변수로 사용하는 생성자가 없습니다.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">문자열 기반 열거형을 역직렬화할 수 없습니다. 예상치 못한 데이터 발생: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">TextDocumentSyncOptions를 역직렬화할 수 없습니다. 예기치 않은 값 {0}이(가) 있습니다.</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.pl.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.pl.xlf
deleted file mode 100644
index ec0d884105ec5..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.pl.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pl" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">Nie można zdeserializować identyfikatora Uri. Napotkano nieoczekiwaną wartość: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">Nie można zdeserializować elementu MarkupContent. Napotkano nieoczekiwaną wartość: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">Typ SumType nie może mieć innego typu SumType jako parametru typu.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">Nie można zdeserializować żadnego z parametrów typu SumType</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">W typie {0} brakuje konstruktora, który przyjmuje pojedynczy ciąg jako parametr.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">Nie można zdeserializować wyliczenia opartego na ciągach. Napotkano nieoczekiwane dane: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">Nie można zdeserializować elementu TextDocumentSyncOptions. Napotkano nieoczekiwaną wartość: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.pt-BR.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.pt-BR.xlf
deleted file mode 100644
index 618e0879d9f6b..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.pt-BR.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="pt-BR" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">Não é possível desserializar o Uri. Valor inesperado encontrado: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">Não é possível desserializar MarkupContent. Valor inesperado encontrado: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">Um SumType não pode ter outro SumType como parâmetro de tipo.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">Nenhum dos parâmetros do tipo SumType pode ser desserializado</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">O tipo {0} falta um construtor que toma uma única corda como parâmetro.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">Não é possível desserializar enumeração baseada em cadeia de caracteres. Dados inesperados encontrados: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">Não é possível desserializar TextDocumentSyncOptions. Valor inesperado encontrado: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ru.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ru.xlf
deleted file mode 100644
index 33fcc20f8bfd1..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.ru.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="ru" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">Не удалось десериализовать URI. Возникло непредвиденное значение: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">Не удалось десериализовать MarkupContent. Возникло непредвиденное значение: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">SumType не может иметь другой SumType в качестве параметра типа.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">Невозможно десериализировать ни один из параметров типа SumType</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">В типе {0} отсутствует конструктор, принимающий одну строку в качестве параметра.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">Не удалось десериализовать перечисление на основе строк. Обнаружены непредвиденные данные: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">Не удалось десериализовать TextDocumentSyncOptions. Возникло непредвиденное значение: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.tr.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.tr.xlf
deleted file mode 100644
index 51564d4b1adb5..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.tr.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="tr" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">URI seri durumdan çıkarılamıyor. Beklenmeyen değerle karşılaşıldı: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">MarkupContent seri durumdan çıkarılamıyor. Beklenmeyen değerle karşılaşıldı: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">SumType, tür parametresi olarak başka bir SumType'a sahip olamaz.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">SumType tür parametrelerinin hiçbiri seri durumdan çıkarılamadı</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">{0} türünde parametre olarak tek bir dize alan bir yapıcı yok.</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">Dize tabanlı sabit listesi seri durumdan çıkarılamıyor. Beklenmeyen veriyle karşılaşıldı: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">TextDocumentSyncOptions seri durumdan çıkarılamıyor. Beklenmeyen değerle karşılaşıldı: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.zh-Hans.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.zh-Hans.xlf
deleted file mode 100644
index 5f5fec71c7d25..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.zh-Hans.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hans" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">无法反序列化 URI。出现意外值: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">无法反序列化 MarkupContent。出现意外值: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">SumType 不能将另一个 SumType 作为类型参数。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">无法反序列化任何 SumType 类型参数</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">类型 {0} 缺少一个将单个字符串用作参数的构造函数。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">无法反序列化基于字符串的枚举。遇到意外数据: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">无法反序列化 TextDocumentSyncOptions。出现意外值: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.zh-Hant.xlf b/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.zh-Hant.xlf
deleted file mode 100644
index b2cd9ad11bfc1..0000000000000
--- a/src/Features/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/xlf/LSPFrameworkResources.zh-Hant.xlf
+++ /dev/null
@@ -1,42 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
-  <file datatype="xml" source-language="en" target-language="zh-Hant" original="../LSPFrameworkResources.resx">
-    <body>
-      <trans-unit id="DocumentUriSerializationError">
-        <source>Unable to deserialize Uri. Unexpected value encountered: {0}</source>
-        <target state="translated">無法將 URI 還原序列化。發現非預期的值: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="MarkupContentSerializationError">
-        <source>Unable to deserialize MarkupContent. Unexpected value encountered: {0}</source>
-        <target state="translated">無法將 MarkupContent 還原序列化。發現非預期的值: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NestedSumType">
-        <source>A SumType cannot have another SumType as type parameter.</source>
-        <target state="translated">SumType 不能有另一個 SumType 做為型別參數。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="NoSumTypeMatch">
-        <source>None of the SumType type parameters could be deserialized</source>
-        <target state="translated">沒有可還原序列化的 SumType 型別參數</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumMissingConstructor">
-        <source>Type {0} is missing a contructor that takes a single string as parameter.</source>
-        <target state="translated">{0} 類型缺少使用單一字串做為參數的建構函式。</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="StringEnumSerializationError">
-        <source>Unable to deserialize string-based enum. Unexpected data encountered: {0}</source>
-        <target state="translated">無法將字串型列舉還原序列化。發現未預期的資料: {0}</target>
-        <note />
-      </trans-unit>
-      <trans-unit id="TextDocumentSyncSerializationError">
-        <source>Unable to deserialize TextDocumentSyncOptions.  Unexpected value encountered: {0}</source>
-        <target state="translated">無法將 TextDocumentSyncOptions 還原序列化。發現非預期的值: {0}</target>
-        <note />
-      </trans-unit>
-    </body>
-  </file>
-</xliff>
\ No newline at end of file
diff --git a/src/Features/LanguageServer/Protocol/Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj b/src/Features/LanguageServer/Protocol/Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj
index 2d42aa74a73b4..df5d1f713bcd7 100644
--- a/src/Features/LanguageServer/Protocol/Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj
+++ b/src/Features/LanguageServer/Protocol/Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj
@@ -15,10 +15,10 @@
     <ProjectReference Include="..\..\..\Compilers\CSharp\Portable\Microsoft.CodeAnalysis.CSharp.csproj" />
     <ProjectReference Include="..\..\..\Workspaces\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj" />
     <ProjectReference Include="..\..\Core\Portable\Microsoft.CodeAnalysis.Features.csproj" />
-    <ProjectReference Include="..\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.csproj" />
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="StreamJsonRpc" />
     <PackageReference Include="ICSharpCode.Decompiler" />
   </ItemGroup>
 
@@ -70,13 +70,13 @@
     <InternalsVisibleTo Include="IdeCoreBenchmarks" />
     <InternalsVisibleTo Include="IdeBenchmarks" />
     <InternalsVisibleTo Include="AnalyzerRunner" />
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.Debugger"/>
+    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.Debugger" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.CompilerDeveloperSDK" />
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.Razor.UnitTests"/>
-    <InternalsVisibleTo Include="Microsoft.CommonLanguageServerProtocol.Framework.Example"/>
-    <InternalsVisibleTo Include="Microsoft.CommonLanguageServerProtocol.Framework.UnitTests"/>
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Features.DiagnosticsTests.Utilities"/>
-    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Features.Test.Utilities"/>
+    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.Razor.UnitTests" />
+    <InternalsVisibleTo Include="Microsoft.CommonLanguageServerProtocol.Framework.Example" />
+    <InternalsVisibleTo Include="Microsoft.CommonLanguageServerProtocol.Framework.UnitTests" />
+    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Features.DiagnosticsTests.Utilities" />
+    <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Features.Test.Utilities" />
   </ItemGroup>
 
   <ItemGroup>
@@ -104,4 +104,6 @@
     </EmbeddedResource>
   </ItemGroup>
 
+  <Import Project="..\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.Shared.projitems" Label="Shared" />
+
 </Project>
diff --git a/src/Tools/ExternalAccess/CompilerDeveloperSDK/Microsoft.CodeAnalysis.ExternalAccess.CompilerDeveloperSDK.csproj b/src/Tools/ExternalAccess/CompilerDeveloperSDK/Microsoft.CodeAnalysis.ExternalAccess.CompilerDeveloperSDK.csproj
index b7f896ff02213..d567a1b9dea0a 100644
--- a/src/Tools/ExternalAccess/CompilerDeveloperSDK/Microsoft.CodeAnalysis.ExternalAccess.CompilerDeveloperSDK.csproj
+++ b/src/Tools/ExternalAccess/CompilerDeveloperSDK/Microsoft.CodeAnalysis.ExternalAccess.CompilerDeveloperSDK.csproj
@@ -20,7 +20,6 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\..\Features\LanguageServer\Microsoft.CodeAnalysis.LanguageServer\Microsoft.CodeAnalysis.LanguageServer.csproj" PrivateAssets="all" />
-    <ProjectReference Include="..\..\..\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj b/src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj
index a935edd881c38..370d875201436 100644
--- a/src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj
+++ b/src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj
@@ -15,6 +15,10 @@
     </PackageDescription>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Utilities\IsExternalInit.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <!--
       ⚠ ONLY F# ASSEMBLIES MAY BE ADDED HERE ⚠
diff --git a/src/Tools/ExternalAccess/Razor/Microsoft.CodeAnalysis.ExternalAccess.Razor.csproj b/src/Tools/ExternalAccess/Razor/Microsoft.CodeAnalysis.ExternalAccess.Razor.csproj
index f72a70e6deaa5..e290c83802b62 100644
--- a/src/Tools/ExternalAccess/Razor/Microsoft.CodeAnalysis.ExternalAccess.Razor.csproj
+++ b/src/Tools/ExternalAccess/Razor/Microsoft.CodeAnalysis.ExternalAccess.Razor.csproj
@@ -15,6 +15,10 @@
     <ExcludeFromVerticalBuild>false</ExcludeFromVerticalBuild>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Utilities\IsExternalInit.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Remote.ServiceHub" />
 
diff --git a/src/Tools/ExternalAccess/Xaml/External/IXamlRequestHandler.cs b/src/Tools/ExternalAccess/Xaml/External/IXamlRequestHandler.cs
index 7ee8ea33fb66c..c66ce9c57eafa 100644
--- a/src/Tools/ExternalAccess/Xaml/External/IXamlRequestHandler.cs
+++ b/src/Tools/ExternalAccess/Xaml/External/IXamlRequestHandler.cs
@@ -2,11 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using Microsoft.CommonLanguageServerProtocol.Framework;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Microsoft.CodeAnalysis.ExternalAccess.Xaml;
 
 internal interface IXamlRequestHandler<TRequest, TResponse>
-    : IRequestHandler<TRequest, TResponse, XamlRequestContext>
 {
+    Task<TResponse> HandleRequestAsync(TRequest request, XamlRequestContext context, CancellationToken cancellationToken);
+
+    bool MutatesSolutionState { get; }
 }
diff --git a/src/Tools/ExternalAccess/Xaml/InternalAPI.Unshipped.txt b/src/Tools/ExternalAccess/Xaml/InternalAPI.Unshipped.txt
index e947cc2b91b1e..fcf69c84b9ade 100644
--- a/src/Tools/ExternalAccess/Xaml/InternalAPI.Unshipped.txt
+++ b/src/Tools/ExternalAccess/Xaml/InternalAPI.Unshipped.txt
@@ -38,6 +38,8 @@ Microsoft.CodeAnalysis.ExternalAccess.Xaml.IResolveCachedDataService
 Microsoft.CodeAnalysis.ExternalAccess.Xaml.IResolveCachedDataService.FromResolveData(object? resolveData) -> (object? data, System.Uri? uri)
 Microsoft.CodeAnalysis.ExternalAccess.Xaml.IResolveCachedDataService.ToResolveData(object! data, System.Uri! uri) -> object!
 Microsoft.CodeAnalysis.ExternalAccess.Xaml.IXamlRequestHandler<TRequest, TResponse>
+Microsoft.CodeAnalysis.ExternalAccess.Xaml.IXamlRequestHandler<TRequest, TResponse>.HandleRequestAsync(TRequest request, Microsoft.CodeAnalysis.ExternalAccess.Xaml.XamlRequestContext context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<TResponse>!
+Microsoft.CodeAnalysis.ExternalAccess.Xaml.IXamlRequestHandler<TRequest, TResponse>.MutatesSolutionState.get -> bool
 Microsoft.CodeAnalysis.ExternalAccess.Xaml.LocationService
 Microsoft.CodeAnalysis.ExternalAccess.Xaml.LocationService.GetLocationAsync(Microsoft.CodeAnalysis.TextDocument! document, Microsoft.CodeAnalysis.Text.TextSpan textSpan, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.FileLinePositionSpan?>!
 Microsoft.CodeAnalysis.ExternalAccess.Xaml.LocationService.GetSymbolLocationsAsync(Microsoft.CodeAnalysis.ISymbol! symbol, Microsoft.CodeAnalysis.Project! project, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<Microsoft.CodeAnalysis.FileLinePositionSpan[]!>!
diff --git a/src/Tools/ExternalAccess/Xaml/Microsoft.CodeAnalysis.ExternalAccess.Xaml.csproj b/src/Tools/ExternalAccess/Xaml/Microsoft.CodeAnalysis.ExternalAccess.Xaml.csproj
index 535965686e280..d7ed804b17a58 100644
--- a/src/Tools/ExternalAccess/Xaml/Microsoft.CodeAnalysis.ExternalAccess.Xaml.csproj
+++ b/src/Tools/ExternalAccess/Xaml/Microsoft.CodeAnalysis.ExternalAccess.Xaml.csproj
@@ -30,10 +30,13 @@
     <PackageReference Include="System.ComponentModel.Composition" Version="$(SystemComponentModelCompositionVersion)" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Utilities\IsExternalInit.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\..\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj" />
     <ProjectReference Include="..\..\..\Features\Core\Portable\Microsoft.CodeAnalysis.Features.csproj" />
-    <ProjectReference Include="..\..\..\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.csproj" />
     <ProjectReference Include="..\..\..\Features\LanguageServer\Protocol\Microsoft.CodeAnalysis.LanguageServer.Protocol.csproj" />
     <ProjectReference Include="..\..\..\Workspaces\Core\Portable\Microsoft.CodeAnalysis.Workspaces.csproj" />
   </ItemGroup>
diff --git a/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj b/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
index 63ada03ccb5cf..7e04d4e2f999b 100644
--- a/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
+++ b/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
@@ -51,6 +51,9 @@
     <EmbeddedResource Include="ColorSchemes\VisualStudio2019.xml" />
     <EmbeddedResource Include="ColorSchemes\VisualStudio2017.xml" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="InternalUtilities\IsExternalInit.cs" />
+  </ItemGroup>
   <ItemGroup Label="Project References">
     <ProjectReference Include="..\..\..\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj" />
     <ProjectReference Include="..\..\..\EditorFeatures\Core\Microsoft.CodeAnalysis.EditorFeatures.csproj" />
diff --git a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
index 9af768dba8071..9fc7ed1f31784 100644
--- a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
+++ b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
@@ -141,7 +141,7 @@
       <ForceIncludeInVSIX>true</ForceIncludeInVSIX>
       <PkgDefEntry>BindingRedirect</PkgDefEntry>
     </ProjectReference>
-    <ProjectReference Include="..\..\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.csproj">
+    <ProjectReference Include="..\..\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework.Binary\Microsoft.CommonLanguageServerProtocol.Framework.Binary.csproj">
       <Name>Microsoft.CommonLanguageServerProtocolFramework</Name>
       <IncludeOutputGroupsInVSIX>BuiltProjectOutputGroup;SatelliteDllsProjectOutputGroup</IncludeOutputGroupsInVSIX>
       <ForceIncludeInVSIX>true</ForceIncludeInVSIX>
diff --git a/src/Workspaces/CoreTestUtilities/Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj b/src/Workspaces/CoreTestUtilities/Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj
index 283c647522fad..a94132b7f0588 100644
--- a/src/Workspaces/CoreTestUtilities/Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj
+++ b/src/Workspaces/CoreTestUtilities/Microsoft.CodeAnalysis.Workspaces.Test.Utilities.csproj
@@ -34,6 +34,9 @@
   <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
     <PackageReference Include="System.Diagnostics.DiagnosticSource" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\IsExternalInit.cs" Link="Utilities\IsExternalInit.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'" />
+  </ItemGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.CSharp.Features.UnitTests" />

From fb7890e66c5093280bd386e4378adcb5fe199b8f Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Tue, 12 Mar 2024 15:57:35 +1100
Subject: [PATCH 010/170] Update
 src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs

---
 .../Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs b/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
index df56d6e280e2f..a3d07daa66148 100644
--- a/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/SemanticTokens/SemanticTokensHelpers.cs
@@ -55,7 +55,7 @@ internal static async Task<int[]> HandleRequestHelperAsync(
             return tokensData;
         }
 
-        public static async Task<int[]> HandleRequestHelperAsync( Document document, ImmutableArray<LinePositionSpan> spans, bool supportsVisualStudioExtensions, ClassificationOptions options, CancellationToken cancellationToken)
+        public static async Task<int[]> HandleRequestHelperAsync(Document document, ImmutableArray<LinePositionSpan> spans, bool supportsVisualStudioExtensions, ClassificationOptions options, CancellationToken cancellationToken)
         {
             // If the full compilation is not yet available, we'll try getting a partial one. It may contain inaccurate
             // results but will speed up how quickly we can respond to the client's request.

From b75c4c163706aa98330a55681a870626567c4671 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]" <dotnet-maestro[bot]@users.noreply.github.com>
Date: Tue, 12 Mar 2024 12:28:14 +0000
Subject: [PATCH 011/170] Update dependencies from
 https://github.com/dotnet/source-build-externals build 20240311.3

Microsoft.SourceBuild.Intermediate.source-build-externals
 From Version 9.0.0-alpha.1.24158.2 -> To Version 9.0.0-alpha.1.24161.3
---
 eng/Version.Details.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index de5b5f80248b6..b62a2eba19d58 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -2,9 +2,9 @@
 <Dependencies>
   <ProductDependencies>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-externals" Version="9.0.0-alpha.1.24158.2">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-externals" Version="9.0.0-alpha.1.24161.3">
       <Uri>https://github.com/dotnet/source-build-externals</Uri>
-      <Sha>16ece46ae00dd1e8ac30a360d3dd03a6a682db41</Sha>
+      <Sha>472629e451a5a87410ea3670606f7235a4dd5a02</Sha>
       <SourceBuild RepoName="source-build-externals" ManagedOnly="true" />
     </Dependency>
     <!-- Intermediate is necessary for source build. -->

From 5f4a962cf3725cc75029b850e4c3dc47a3f91a62 Mon Sep 17 00:00:00 2001
From: sdelarosbil <sdelarosbil@spiria.com>
Date: Tue, 12 Mar 2024 13:10:16 -0400
Subject: [PATCH 012/170] Do not put an equals and quotes when completing an
 xml attribute if present

---
 ...mentationCommentCompletionProviderTests.cs | 29 +++++++++++++++++++
 .../XmlDocCommentCompletionProvider.cs        |  2 +-
 .../AbstractDocCommentCompletionProvider.cs   |  4 +--
 .../XmlDocCommentCompletionProvider.vb        |  2 +-
 4 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
index 9c6dd8ca0eedc..94ca88f585996 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
@@ -760,6 +760,35 @@ static void Goo()
                 """, "cref", "langword", "href");
         }
 
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/72259")]
+        public async Task SeeAttributeNames2()
+        {
+            var text = """
+                class C
+                {
+                    /// <summary>
+                    /// <see l$$=""/>
+                    /// </summary>
+                    static void Goo()
+                    {
+                    }
+                }
+                """;
+            var expected = """
+                class C
+                {
+                    /// <summary>
+                    /// <see langword=""/>
+                    /// </summary>
+                    static void Goo()
+                    {
+                    }
+                }
+                """;
+
+            await VerifyProviderCommitAsync(text, "langword", expected, null);
+        }
+
         [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/37504")]
         public async Task SeeAlsoAttributeNames()
         {
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
index 0b9617d7fa77f..dd6028ec8a342 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
@@ -85,7 +85,7 @@ public override bool IsInsertionTrigger(SourceText text, int characterPosition,
 
             if (IsAttributeNameContext(token, position, out var elementName, out var existingAttributes))
             {
-                return GetAttributeItems(elementName, existingAttributes);
+                return GetAttributeItems(elementName, existingAttributes, !token.GetNextToken().IsKind(SyntaxKind.EqualsToken));
             }
 
             var wasTriggeredAfterSpace = trigger.Kind == CompletionTriggerKind.Insertion && trigger.Character == ' ';
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
index 4f2066f4253d4..3ee0db19310bc 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
@@ -113,10 +113,10 @@ private CompletionItem GetItem(string name)
         return CreateCompletionItem(name);
     }
 
-    protected IEnumerable<CompletionItem> GetAttributeItems(string tagName, ISet<string> existingAttributes)
+    protected IEnumerable<CompletionItem> GetAttributeItems(string tagName, ISet<string> existingAttributes, bool addEqualsAndQuotes)
     {
         return s_attributeMap.Where(x => x.elementName == tagName && !existingAttributes.Contains(x.attributeName))
-                             .Select(x => CreateCompletionItem(x.attributeName, beforeCaretText: x.text, afterCaretText: "\""));
+                             .Select(x => CreateCompletionItem(x.attributeName, beforeCaretText: addEqualsAndQuotes ? x.text : x.text[..^2], afterCaretText: addEqualsAndQuotes ? "\"" : ""));
     }
 
     protected IEnumerable<CompletionItem> GetAlwaysVisibleItems()
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
index 576a4674aef5d..90fd3b9404964 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
@@ -332,7 +332,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
 
         Private Function GetAttributes(tagName As String, attributes As SyntaxList(Of XmlNodeSyntax)) As IEnumerable(Of CompletionItem)
             Dim existingAttributeNames = attributes.Select(AddressOf GetAttributeName).WhereNotNull().ToSet()
-            Return GetAttributeItems(tagName, existingAttributeNames)
+            Return GetAttributeItems(tagName, existingAttributeNames, false)
         End Function
 
         Private Shared Function GetAttributeName(node As XmlNodeSyntax) As String

From aa638970252d0b22ced6e979a10e036811b8247e Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Tue, 12 Mar 2024 10:24:58 -0700
Subject: [PATCH 013/170] Use the project cone information in
 Scope.FindAssetsAsync

This avoids full solution level searches in scenarios where a project cone is being searched. This was particularly bad when the AssetHint didn't indicate a project/document.
---
 .../Remote/Core/SolutionAssetStorage.Scope.cs   | 17 +++++++++--------
 .../Remote/Core/SolutionAssetStorage.cs         |  2 +-
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
index aa549b72272c8..7e989a7a72509 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
@@ -18,11 +18,13 @@ internal partial class SolutionAssetStorage
     internal sealed partial class Scope(
         SolutionAssetStorage storage,
         Checksum solutionChecksum,
+        ProjectId? projectId,
         SolutionCompilationState compilationState) : IDisposable
     {
         private readonly SolutionAssetStorage _storage = storage;
 
         public readonly Checksum SolutionChecksum = solutionChecksum;
+        public readonly ProjectId? ProjectId = projectId;
         public readonly SolutionCompilationState CompilationState = compilationState;
 
         /// <summary>
@@ -67,15 +69,14 @@ private async Task FindAssetsAsync(
             AssetHint assetHint, HashSet<Checksum> remainingChecksumsToFind, Dictionary<Checksum, object> result, CancellationToken cancellationToken)
         {
             var solutionState = this.CompilationState;
-            if (solutionState.TryGetStateChecksums(out var stateChecksums))
-                await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
-
-            foreach (var projectId in solutionState.SolutionState.ProjectIds)
+            if (ProjectId is null)
             {
-                if (remainingChecksumsToFind.Count == 0)
-                    break;
-
-                if (solutionState.TryGetStateChecksums(projectId, out stateChecksums))
+                if (solutionState.TryGetStateChecksums(out var stateChecksums))
+                    await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                if (solutionState.TryGetStateChecksums(ProjectId, out var stateChecksums))
                     await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
             }
         }
diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.cs
index 061c9b4ddd33e..0287a3dee74e2 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.cs
@@ -76,7 +76,7 @@ public async ValueTask<Scope> StoreAssetsAsync(SolutionCompilationState compilat
                 return scope;
             }
 
-            scope = new Scope(this, checksum, compilationState);
+            scope = new Scope(this, checksum, projectId, compilationState);
             _checksumToScope[checksum] = scope;
             return scope;
         }

From 95b7e3835db5ca0cb3e70e7c4c576c6ffa54152b Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Tue, 12 Mar 2024 10:35:34 -0700
Subject: [PATCH 014/170] Use contract to verify the projectId is valid in the
 solutionstate

---
 src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
index 7e989a7a72509..cc06e923017f2 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
@@ -76,8 +76,9 @@ private async Task FindAssetsAsync(
             }
             else
             {
-                if (solutionState.TryGetStateChecksums(ProjectId, out var stateChecksums))
-                    await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
+                Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(ProjectId, out var stateChecksums));
+
+                await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
             }
         }
 

From efd7530d37d724b7db3f04ecafd2118f84ef3f24 Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Tue, 12 Mar 2024 10:44:28 -0700
Subject: [PATCH 015/170] Contract verify the non-project cone case too

---
 .../Remote/Core/SolutionAssetStorage.Scope.cs     | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
index cc06e923017f2..301a0075ac622 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
@@ -69,17 +69,16 @@ private async Task FindAssetsAsync(
             AssetHint assetHint, HashSet<Checksum> remainingChecksumsToFind, Dictionary<Checksum, object> result, CancellationToken cancellationToken)
         {
             var solutionState = this.CompilationState;
+            SolutionCompilationStateChecksums? stateChecksums;
+
             if (ProjectId is null)
-            {
-                if (solutionState.TryGetStateChecksums(out var stateChecksums))
-                    await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
-            }
+                solutionState.TryGetStateChecksums(out stateChecksums);
             else
-            {
-                Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(ProjectId, out var stateChecksums));
+                solutionState.TryGetStateChecksums(ProjectId, out stateChecksums);
 
-                await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
-            }
+            Contract.ThrowIfNull(stateChecksums);
+
+            await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
         }
 
         public TestAccessor GetTestAccessor()

From b26cf9557988ea20ce88d3cfe4f1125489ca3f7f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 11:33:41 -0700
Subject: [PATCH 016/170] Add more project cone info

---
 .../Solution/SolutionCompilationState.cs      |  9 ++-
 .../SolutionCompilationState_Checksum.cs      | 77 +++++++++++++------
 .../Workspace/Solution/SolutionState.cs       |  9 ++-
 .../Solution/SolutionState_Checksum.cs        | 64 ++++++++-------
 .../Remote/Core/SolutionAssetStorage.Scope.cs | 17 ++--
 5 files changed, 113 insertions(+), 63 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index 524b1c7ea9e3a..63c06209616af 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -69,9 +69,12 @@ private SolutionCompilationState(
         FrozenSourceGeneratedDocumentStates = frozenSourceGeneratedDocumentStates;
 
         // when solution state is changed, we recalculate its checksum
-        _lazyChecksums = AsyncLazy.Create(static (self, c) =>
-            self.ComputeChecksumsAsync(projectId: null, c),
-            arg: this);
+        _lazyChecksums = AsyncLazy.Create(static async (self, cancellationToken) =>
+        {
+            var (checksums, projectCone) = await self.ComputeChecksumsAsync(projectId: null, cancellationToken).ConfigureAwait(false);
+            Contract.ThrowIfTrue(projectCone != null);
+            return checksums;
+        }, arg: this);
         _cachedFrozenSnapshot = cachedFrozenSnapshot ??
             AsyncLazy.Create(synchronousComputeFunction: static (self, c) =>
                 self.ComputeFrozenSnapshot(c),
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
index dd7d83c0b8e4b..a730edce084aa 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
@@ -14,6 +14,18 @@
 
 namespace Microsoft.CodeAnalysis;
 
+internal readonly struct ProjectCone
+{
+    public readonly ProjectId RootProjectId;
+    public readonly IReadOnlySet<ProjectId> ProjectIds;
+
+    public ProjectCone(ProjectId rootProjectId, IReadOnlySet<ProjectId> projectIds)
+    {
+        RootProjectId = rootProjectId;
+        ProjectIds = projectIds;
+    }
+}
+
 internal partial class SolutionCompilationState
 {
     /// <summary>
@@ -27,25 +39,32 @@ internal partial class SolutionCompilationState
     /// Mapping from project-id to the checksums needed to synchronize it over to an OOP host.  Lock this specific
     /// field before reading/writing to it.
     /// </summary>
-    private readonly Dictionary<ProjectId, AsyncLazy<SolutionCompilationStateChecksums>> _lazyProjectChecksums = [];
+    private readonly Dictionary<ProjectId, AsyncLazy<(SolutionCompilationStateChecksums checksums, ProjectCone projectCone)>> _lazyProjectChecksums = [];
 
     public bool TryGetStateChecksums([NotNullWhen(true)] out SolutionCompilationStateChecksums? stateChecksums)
         => _lazyChecksums.TryGetValue(out stateChecksums);
 
     public bool TryGetStateChecksums(ProjectId projectId, [NotNullWhen(true)] out SolutionCompilationStateChecksums? stateChecksums)
     {
-        AsyncLazy<SolutionCompilationStateChecksums>? checksums;
+        AsyncLazy<(SolutionCompilationStateChecksums checksums, ProjectCone projectCone)>? lazyChecksums;
         lock (_lazyProjectChecksums)
         {
-            if (!_lazyProjectChecksums.TryGetValue(projectId, out checksums) ||
-                checksums == null)
+            if (!_lazyProjectChecksums.TryGetValue(projectId, out lazyChecksums) ||
+                lazyChecksums == null)
             {
                 stateChecksums = null;
                 return false;
             }
         }
 
-        return checksums.TryGetValue(out stateChecksums);
+        if (lazyChecksums.TryGetValue(out var checksumsAndCone))
+        {
+            stateChecksums = null;
+            return false;
+        }
+
+        stateChecksums = checksumsAndCone.checksums;
+        return true;
     }
 
     public Task<SolutionCompilationStateChecksums> GetStateChecksumsAsync(CancellationToken cancellationToken)
@@ -58,22 +77,25 @@ public async Task<Checksum> GetChecksumAsync(CancellationToken cancellationToken
     }
 
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
-    public async Task<SolutionCompilationStateChecksums> GetStateChecksumsAsync(
-        ProjectId projectId,
+    public async Task<(SolutionCompilationStateChecksums checksums, ProjectCone projectCone)> GetStateChecksumsAsync(
+        ProjectId projectConeId,
         CancellationToken cancellationToken)
     {
-        Contract.ThrowIfNull(projectId);
+        Contract.ThrowIfNull(projectConeId);
 
-        AsyncLazy<SolutionCompilationStateChecksums>? checksums;
+        AsyncLazy<(SolutionCompilationStateChecksums checksums, ProjectCone projectCone)>? checksums;
         lock (_lazyProjectChecksums)
         {
-            if (!_lazyProjectChecksums.TryGetValue(projectId, out checksums))
+            if (!_lazyProjectChecksums.TryGetValue(projectConeId, out checksums))
             {
-                checksums = AsyncLazy.Create(static (arg, c) =>
-                    arg.self.ComputeChecksumsAsync(arg.projectId, c),
-                    arg: (self: this, projectId));
+                checksums = AsyncLazy.Create(static async (arg, cancellationToken) =>
+                {
+                    var (checksum, projectCone) = await arg.self.ComputeChecksumsAsync(arg.projectConeId, cancellationToken).ConfigureAwait(false);
+                    Contract.ThrowIfNull(projectCone);
+                    return (checksum, projectCone.Value);
+                }, arg: (self: this, projectConeId));
 
-                _lazyProjectChecksums.Add(projectId, checksums);
+                _lazyProjectChecksums.Add(projectConeId, checksums);
             }
         }
 
@@ -82,13 +104,13 @@ public async Task<SolutionCompilationStateChecksums> GetStateChecksumsAsync(
     }
 
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
-    public async Task<Checksum> GetChecksumAsync(ProjectId projectId, CancellationToken cancellationToken)
+    public async Task<(Checksum checksum, ProjectCone projectCone)> GetChecksumAsync(ProjectId projectId, CancellationToken cancellationToken)
     {
-        var checksums = await GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
-        return checksums.Checksum;
+        var (checksums, projectCone) = await GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
+        return (checksums.Checksum, projectCone);
     }
 
-    private async Task<SolutionCompilationStateChecksums> ComputeChecksumsAsync(
+    private async Task<(SolutionCompilationStateChecksums checksums, ProjectCone? projectCone)> ComputeChecksumsAsync(
         ProjectId? projectId,
         CancellationToken cancellationToken)
     {
@@ -96,9 +118,19 @@ private async Task<SolutionCompilationStateChecksums> ComputeChecksumsAsync(
         {
             using (Logger.LogBlock(FunctionId.SolutionCompilationState_ComputeChecksumsAsync, this.SolutionState.FilePath, cancellationToken))
             {
-                var solutionStateChecksum = projectId == null
-                    ? await this.SolutionState.GetChecksumAsync(cancellationToken).ConfigureAwait(false)
-                    : await this.SolutionState.GetChecksumAsync(projectId, cancellationToken).ConfigureAwait(false);
+                Checksum solutionStateChecksum;
+                ProjectCone? projectCone;
+
+                if (projectId is null)
+                {
+                    solutionStateChecksum = await this.SolutionState.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
+                    projectCone = null;
+                }
+                else
+                {
+                    (var stateChecksums, projectCone) = await this.SolutionState.GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
+                    solutionStateChecksum = stateChecksums.Checksum;
+                }
 
                 ChecksumCollection? frozenSourceGeneratedDocumentIdentities = null;
                 ChecksumsAndIds<DocumentId>? frozenSourceGeneratedDocuments = null;
@@ -112,10 +144,11 @@ private async Task<SolutionCompilationStateChecksums> ComputeChecksumsAsync(
                     frozenSourceGeneratedDocuments = await FrozenSourceGeneratedDocumentStates.Value.GetChecksumsAndIdsAsync(cancellationToken).ConfigureAwait(false);
                 }
 
-                return new SolutionCompilationStateChecksums(
+                var compilationStateChecksums = new SolutionCompilationStateChecksums(
                     solutionStateChecksum,
                     frozenSourceGeneratedDocumentIdentities,
                     frozenSourceGeneratedDocuments);
+                return (compilationStateChecksums, projectCone);
             }
         }
         catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
index 3e6200977dde5..55a51fc200de6 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
@@ -74,9 +74,12 @@ private SolutionState(
         _lazyAnalyzers = lazyAnalyzers ?? CreateLazyHostDiagnosticAnalyzers(analyzerReferences);
 
         // when solution state is changed, we recalculate its checksum
-        _lazyChecksums = AsyncLazy.Create(static (self, c) =>
-            self.ComputeChecksumsAsync(projectConeId: null, c),
-            arg: this);
+        _lazyChecksums = AsyncLazy.Create(static async (self, cancellationToken) =>
+        {
+            var (checksums, projectCone) = await self.ComputeChecksumsAsync(projectConeId: null, cancellationToken).ConfigureAwait(false);
+            Contract.ThrowIfTrue(projectCone != null);
+            return checksums;
+        }, arg: this);
 
         CheckInvariants();
 
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index 50e95e08fa857..384a43b98ce2e 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -33,7 +33,7 @@ internal partial class SolutionState
     /// Mapping from project-id to the checksums needed to synchronize it (and the projects it depends on) over 
     /// to an OOP host.  Lock this specific field before reading/writing to it.
     /// </summary>
-    private readonly Dictionary<ProjectId, AsyncLazy<SolutionStateChecksums>> _lazyProjectChecksums = [];
+    private readonly Dictionary<ProjectId, AsyncLazy<(SolutionStateChecksums stateChecksums, ProjectCone projectCone)>> _lazyProjectChecksums = [];
 
     public static IReadOnlyList<ProjectId> GetOrCreateSortedProjectIds(IReadOnlyList<ProjectId> unorderedList)
         => s_projectIdToSortedProjectsMap.GetValue(unorderedList, projectIds => projectIds.OrderBy(id => id.Id).ToImmutableArray());
@@ -43,18 +43,25 @@ public bool TryGetStateChecksums([NotNullWhen(true)] out SolutionStateChecksums?
 
     public bool TryGetStateChecksums(ProjectId projectId, [NotNullWhen(true)] out SolutionStateChecksums? stateChecksums)
     {
-        AsyncLazy<SolutionStateChecksums>? checksums;
+        AsyncLazy<(SolutionStateChecksums checksums, ProjectCone projectCone)>? lazyChecksums;
         lock (_lazyProjectChecksums)
         {
-            if (!_lazyProjectChecksums.TryGetValue(projectId, out checksums) ||
-                checksums == null)
+            if (!_lazyProjectChecksums.TryGetValue(projectId, out lazyChecksums) ||
+                lazyChecksums == null)
             {
                 stateChecksums = null;
                 return false;
             }
         }
 
-        return checksums.TryGetValue(out stateChecksums);
+        if (lazyChecksums.TryGetValue(out var checksumsAndProjectCone))
+        {
+            stateChecksums = null;
+            return false;
+        }
+
+        stateChecksums = checksumsAndProjectCone.checksums;
+        return true;
     }
 
     public Task<SolutionStateChecksums> GetStateChecksumsAsync(CancellationToken cancellationToken)
@@ -67,50 +74,51 @@ public async Task<Checksum> GetChecksumAsync(CancellationToken cancellationToken
     }
 
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
-    public async Task<SolutionStateChecksums> GetStateChecksumsAsync(
-        ProjectId projectId,
+    public async Task<(SolutionStateChecksums stateChecksums, ProjectCone projectCone)> GetStateChecksumsAsync(
+        ProjectId projectConeId,
         CancellationToken cancellationToken)
     {
-        Contract.ThrowIfNull(projectId);
+        Contract.ThrowIfNull(projectConeId);
 
-        AsyncLazy<SolutionStateChecksums>? checksums;
+        AsyncLazy<(SolutionStateChecksums stateChecksums, ProjectCone projectCone)>? checksums;
         lock (_lazyProjectChecksums)
         {
-            if (!_lazyProjectChecksums.TryGetValue(projectId, out checksums))
+            if (!_lazyProjectChecksums.TryGetValue(projectConeId, out checksums))
             {
-                checksums = Compute(projectId);
-                _lazyProjectChecksums.Add(projectId, checksums);
+                checksums = AsyncLazy.Create(static async (arg, cancellationToken) =>
+                {
+                    var (checksums, projectCone) = await arg.self.ComputeChecksumsAsync(arg.projectConeId, cancellationToken).ConfigureAwait(false);
+                    Contract.ThrowIfNull(projectCone);
+                    return (checksums, projectCone.Value);
+                }, arg: (self: this, projectConeId));
+                _lazyProjectChecksums.Add(projectConeId, checksums);
             }
         }
 
         var collection = await checksums.GetValueAsync(cancellationToken).ConfigureAwait(false);
         return collection;
-
-        // Extracted as a local function to prevent delegate allocations when not needed.
-        AsyncLazy<SolutionStateChecksums> Compute(ProjectId projectConeId)
-        {
-            return AsyncLazy.Create(static (arg, c) =>
-                arg.self.ComputeChecksumsAsync(arg.projectConeId, c),
-                arg: (self: this, projectConeId));
-        }
     }
 
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
     public async Task<Checksum> GetChecksumAsync(ProjectId projectId, CancellationToken cancellationToken)
     {
-        var checksums = await GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
+        var (checksums, _) = await GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
         return checksums.Checksum;
     }
 
     /// <param name="projectConeId">Cone of projects to compute a checksum for.  Pass in <see langword="null"/> to get a
     /// checksum for the entire solution</param>
-    private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
+    private async Task<(SolutionStateChecksums stateChecksums, ProjectCone? projectCone)> ComputeChecksumsAsync(
         ProjectId? projectConeId,
         CancellationToken cancellationToken)
     {
-        using var projectCone = SharedPools.Default<HashSet<ProjectId>>().GetPooledObject();
+        var projectConeSet = projectConeId is null ? null : new HashSet<ProjectId>();
         AddProjectCone(projectConeId);
 
+        ProjectCone? projectCone = projectConeId is null
+            ? null
+            : new ProjectCone(projectConeId, SpecializedCollections.StronglyTypedReadOnlySet(projectConeSet!));
+
         try
         {
             using (Logger.LogBlock(FunctionId.SolutionState_ComputeChecksumsAsync, this.FilePath, cancellationToken))
@@ -127,7 +135,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                     if (!RemoteSupportedLanguages.IsSupported(projectState.Language))
                         continue;
 
-                    if (projectConeId != null && !projectCone.Object.Contains(orderedProjectId))
+                    if (projectConeId != null && !projectConeSet!.Contains(orderedProjectId))
                         continue;
 
                     projectChecksumTasks.Add(projectState.GetStateChecksumsAsync(cancellationToken));
@@ -141,11 +149,13 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                 var analyzerReferenceChecksums = ChecksumCache.GetOrCreateChecksumCollection(
                     this.AnalyzerReferences, this.Services.GetRequiredService<ISerializerService>(), cancellationToken);
 
-                return new SolutionStateChecksums(
+                var stateChecksums = new SolutionStateChecksums(
                     projectConeId,
                     this.SolutionAttributes.Checksum,
                     new(new ChecksumCollection(projectChecksums), projectIds),
                     analyzerReferenceChecksums);
+
+                return (stateChecksums, projectCone);
             }
         }
         catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
@@ -155,10 +165,10 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
 
         void AddProjectCone(ProjectId? projectConeId)
         {
-            if (projectConeId is null)
+            if (projectConeId is null || projectConeSet is null)
                 return;
 
-            if (!projectCone.Object.Add(projectConeId))
+            if (!projectConeSet.Add(projectConeId))
                 return;
 
             var projectState = this.GetProjectState(projectConeId);
diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
index 301a0075ac622..2a4f6acc359c7 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
@@ -18,7 +18,7 @@ internal partial class SolutionAssetStorage
     internal sealed partial class Scope(
         SolutionAssetStorage storage,
         Checksum solutionChecksum,
-        ProjectId? projectId,
+        ProjectCone projectCone,
         SolutionCompilationState compilationState) : IDisposable
     {
         private readonly SolutionAssetStorage _storage = storage;
@@ -69,16 +69,17 @@ private async Task FindAssetsAsync(
             AssetHint assetHint, HashSet<Checksum> remainingChecksumsToFind, Dictionary<Checksum, object> result, CancellationToken cancellationToken)
         {
             var solutionState = this.CompilationState;
-            SolutionCompilationStateChecksums? stateChecksums;
 
             if (ProjectId is null)
-                solutionState.TryGetStateChecksums(out stateChecksums);
+            {
+                Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(out var stateChecksums));
+                await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
+            }
             else
-                solutionState.TryGetStateChecksums(ProjectId, out stateChecksums);
-
-            Contract.ThrowIfNull(stateChecksums);
-
-            await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
+            {
+                Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(ProjectId, out var stateChecksums));
+                await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
+            }
         }
 
         public TestAccessor GetTestAccessor()

From 7a83e996bd69e19c1b10c5e456802b8eec2d6b0e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 11:49:15 -0700
Subject: [PATCH 017/170] Add more project cone info

---
 .../SolutionCompilationState_Checksum.cs      |  6 +--
 .../Solution/SolutionState_Checksum.cs        |  8 ++--
 .../Workspace/Solution/StateChecksums.cs      | 40 ++++++++++++++-----
 .../Remote/Core/SolutionAssetStorage.Scope.cs | 15 ++++---
 .../Remote/Core/SolutionAssetStorage.cs       | 18 +++++++--
 .../Remote/ServiceHub/Host/TestUtils.cs       | 17 ++++----
 6 files changed, 68 insertions(+), 36 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
index a730edce084aa..b7872fa8ee440 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
@@ -104,10 +104,10 @@ public async Task<Checksum> GetChecksumAsync(CancellationToken cancellationToken
     }
 
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
-    public async Task<(Checksum checksum, ProjectCone projectCone)> GetChecksumAsync(ProjectId projectId, CancellationToken cancellationToken)
+    public async Task<Checksum> GetChecksumAsync(ProjectId projectId, CancellationToken cancellationToken)
     {
-        var (checksums, projectCone) = await GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
-        return (checksums.Checksum, projectCone);
+        var (checksums, _) = await GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
+        return checksums.Checksum;
     }
 
     private async Task<(SolutionCompilationStateChecksums checksums, ProjectCone? projectCone)> ComputeChecksumsAsync(
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index 384a43b98ce2e..fa278cd606deb 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -33,7 +33,7 @@ internal partial class SolutionState
     /// Mapping from project-id to the checksums needed to synchronize it (and the projects it depends on) over 
     /// to an OOP host.  Lock this specific field before reading/writing to it.
     /// </summary>
-    private readonly Dictionary<ProjectId, AsyncLazy<(SolutionStateChecksums stateChecksums, ProjectCone projectCone)>> _lazyProjectChecksums = [];
+    private readonly Dictionary<ProjectId, AsyncLazy<(SolutionStateChecksums checksums, ProjectCone projectCone)>> _lazyProjectChecksums = [];
 
     public static IReadOnlyList<ProjectId> GetOrCreateSortedProjectIds(IReadOnlyList<ProjectId> unorderedList)
         => s_projectIdToSortedProjectsMap.GetValue(unorderedList, projectIds => projectIds.OrderBy(id => id.Id).ToImmutableArray());
@@ -74,13 +74,13 @@ public async Task<Checksum> GetChecksumAsync(CancellationToken cancellationToken
     }
 
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
-    public async Task<(SolutionStateChecksums stateChecksums, ProjectCone projectCone)> GetStateChecksumsAsync(
+    public async Task<(SolutionStateChecksums checksums, ProjectCone projectCone)> GetStateChecksumsAsync(
         ProjectId projectConeId,
         CancellationToken cancellationToken)
     {
         Contract.ThrowIfNull(projectConeId);
 
-        AsyncLazy<(SolutionStateChecksums stateChecksums, ProjectCone projectCone)>? checksums;
+        AsyncLazy<(SolutionStateChecksums checksums, ProjectCone projectCone)>? checksums;
         lock (_lazyProjectChecksums)
         {
             if (!_lazyProjectChecksums.TryGetValue(projectConeId, out checksums))
@@ -108,7 +108,7 @@ public async Task<Checksum> GetChecksumAsync(ProjectId projectId, CancellationTo
 
     /// <param name="projectConeId">Cone of projects to compute a checksum for.  Pass in <see langword="null"/> to get a
     /// checksum for the entire solution</param>
-    private async Task<(SolutionStateChecksums stateChecksums, ProjectCone? projectCone)> ComputeChecksumsAsync(
+    private async Task<(SolutionStateChecksums checksums, ProjectCone? projectCone)> ComputeChecksumsAsync(
         ProjectId? projectConeId,
         CancellationToken cancellationToken)
     {
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs b/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
index a503a170120ac..106e89044e6f1 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
@@ -88,6 +88,7 @@ public static SolutionCompilationStateChecksums Deserialize(ObjectReader reader)
 
     public async Task FindAsync(
         SolutionCompilationState compilationState,
+        ProjectCone? projectCone,
         AssetHint assetHint,
         HashSet<Checksum> searchingChecksumsLeft,
         Dictionary<Checksum, object> result,
@@ -123,16 +124,18 @@ public async Task FindAsync(
         }
 
         var solutionState = compilationState.SolutionState;
-        if (solutionState.TryGetStateChecksums(out var solutionChecksums))
-            await solutionChecksums.FindAsync(solutionState, assetHint, searchingChecksumsLeft, result, cancellationToken).ConfigureAwait(false);
-
-        foreach (var projectId in solutionState.ProjectIds)
+        if (projectCone is null)
         {
-            if (searchingChecksumsLeft.Count == 0)
-                break;
-
-            if (solutionState.TryGetStateChecksums(projectId, out solutionChecksums))
-                await solutionChecksums.FindAsync(solutionState, assetHint, searchingChecksumsLeft, result, cancellationToken).ConfigureAwait(false);
+            // If we're not in a project cone, start the search at the top most state-checksum corresponding to the
+            // entire solution.
+            Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(out var solutionChecksums));
+            await solutionChecksums.FindAsync(solutionState, projectCone, assetHint, searchingChecksumsLeft, result, cancellationToken).ConfigureAwait(false);
+        }
+        else
+        {
+            // Otherwise, grab the top-most state checksum for this cone and search within that.
+            Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(projectCone.Value.RootProjectId, out var solutionChecksums));
+            await solutionChecksums.FindAsync(solutionState, projectCone, assetHint, searchingChecksumsLeft, result, cancellationToken).ConfigureAwait(false);
         }
     }
 }
@@ -193,6 +196,7 @@ public static SolutionStateChecksums Deserialize(ObjectReader reader)
 
     public async Task FindAsync(
         SolutionState solution,
+        ProjectCone? projectCone,
         AssetHint assetHint,
         HashSet<Checksum> searchingChecksumsLeft,
         Dictionary<Checksum, object> result,
@@ -216,6 +220,10 @@ public async Task FindAsync(
 
         if (assetHint.ProjectId != null)
         {
+            Contract.ThrowIfTrue(
+                projectCone != null && !projectCone.Value.ProjectIds.Contains(assetHint.ProjectId),
+                "Requesting an asset outside of the cone explicitly being asked for!");
+
             var projectState = solution.GetProjectState(assetHint.ProjectId);
             if (projectState != null &&
                 projectState.TryGetStateChecksums(out var projectStateChecksums))
@@ -231,11 +239,16 @@ public async Task FindAsync(
             // level. This ensures that when we are trying to sync the projects referenced by a SolutionStateChecksums'
             // instance that we don't unnecessarily walk all documents looking just for those.
 
-            foreach (var (_, projectState) in solution.ProjectStates)
+            foreach (var (projectId, projectState) in solution.ProjectStates)
             {
                 if (searchingChecksumsLeft.Count == 0)
                     break;
 
+                // If we're syncing a project cone, no point at all at looking at child projects of the solution that
+                // are not in that cone.
+                if (projectCone != null && !projectCone.Value.ProjectIds.Contains(projectId))
+                    continue;
+
                 if (projectState.TryGetStateChecksums(out var projectStateChecksums) &&
                     searchingChecksumsLeft.Remove(projectStateChecksums.Checksum))
                 {
@@ -245,11 +258,16 @@ public async Task FindAsync(
 
             // Now actually do the depth first search into each project.
 
-            foreach (var (_, projectState) in solution.ProjectStates)
+            foreach (var (projectId, projectState) in solution.ProjectStates)
             {
                 if (searchingChecksumsLeft.Count == 0)
                     break;
 
+                // If we're syncing a project cone, no point at all at looking at child projects of the solution that
+                // are not in that cone.
+                if (projectCone != null && !projectCone.Value.ProjectIds.Contains(projectId))
+                    continue;
+
                 // It's possible not all all our projects have checksums.  Specifically, we may have only been asked to
                 // compute the checksum tree for a subset of projects that were all that a feature needed.
                 if (projectState.TryGetStateChecksums(out var projectStateChecksums))
diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
index 2a4f6acc359c7..d8b59a0670f12 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
@@ -18,13 +18,13 @@ internal partial class SolutionAssetStorage
     internal sealed partial class Scope(
         SolutionAssetStorage storage,
         Checksum solutionChecksum,
-        ProjectCone projectCone,
+        ProjectCone? projectCone,
         SolutionCompilationState compilationState) : IDisposable
     {
         private readonly SolutionAssetStorage _storage = storage;
 
         public readonly Checksum SolutionChecksum = solutionChecksum;
-        public readonly ProjectId? ProjectId = projectId;
+        public readonly ProjectCone? ProjectCone = projectCone;
         public readonly SolutionCompilationState CompilationState = compilationState;
 
         /// <summary>
@@ -70,15 +70,18 @@ private async Task FindAssetsAsync(
         {
             var solutionState = this.CompilationState;
 
-            if (ProjectId is null)
+            if (this.ProjectCone is null)
             {
+                // If we're not in a project cone, start the search at the top most state-checksum corresponding to the
+                // entire solution.
                 Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(out var stateChecksums));
-                await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
+                await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
             }
             else
             {
-                Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(ProjectId, out var stateChecksums));
-                await stateChecksums.FindAsync(solutionState, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
+                // Otherwise, grab the top-most state checksum for this cone and search within that.
+                Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(this.ProjectCone.Value.RootProjectId, out var stateChecksums));
+                await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
             }
         }
 
diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.cs
index 0287a3dee74e2..841b07901f7a8 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.cs
@@ -63,9 +63,19 @@ public ValueTask<Scope> StoreAssetsAsync(SolutionCompilationState compilationSta
     /// <inheritdoc cref="StoreAssetsAsync(Solution, CancellationToken)"/>
     public async ValueTask<Scope> StoreAssetsAsync(SolutionCompilationState compilationState, ProjectId? projectId, CancellationToken cancellationToken)
     {
-        var checksum = projectId == null
-            ? await compilationState.GetChecksumAsync(cancellationToken).ConfigureAwait(false)
-            : await compilationState.GetChecksumAsync(projectId, cancellationToken).ConfigureAwait(false);
+        Checksum checksum;
+        ProjectCone? projectCone;
+
+        if (projectId == null)
+        {
+            checksum = await compilationState.GetChecksumAsync(cancellationToken).ConfigureAwait(false);
+            projectCone = null;
+        }
+        else
+        {
+            (var stateChecksums, projectCone) = await compilationState.GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
+            checksum = stateChecksums.Checksum;
+        }
 
         lock (_gate)
         {
@@ -76,7 +86,7 @@ public async ValueTask<Scope> StoreAssetsAsync(SolutionCompilationState compilat
                 return scope;
             }
 
-            scope = new Scope(this, checksum, projectId, compilationState);
+            scope = new Scope(this, checksum, projectCone, compilationState);
             _checksumToScope[checksum] = scope;
             return scope;
         }
diff --git a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
index 4e84b56321074..b124eceb4bfba 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
@@ -189,35 +189,36 @@ public static async Task<Dictionary<Checksum, object>> GetAssetMapAsync(this Pro
         }
 
         public static Task AppendAssetMapAsync(this Solution solution, Dictionary<Checksum, object> map, CancellationToken cancellationToken)
-            => AppendAssetMapAsync(solution, map, projectId: null, cancellationToken);
+            => AppendAssetMapAsync(solution, projectCone: null, map, cancellationToken);
 
         public static async Task AppendAssetMapAsync(
-            this Solution solution, Dictionary<Checksum, object> map, ProjectId? projectId, CancellationToken cancellationToken)
+            this Solution solution, ProjectCone? projectCone, Dictionary<Checksum, object> map, CancellationToken cancellationToken)
         {
-            if (projectId == null)
+            if (projectCone == null)
             {
                 var compilationChecksums = await solution.CompilationState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
-                await compilationChecksums.FindAsync(solution.CompilationState, assetHint: AssetHint.None, Flatten(compilationChecksums), map, cancellationToken).ConfigureAwait(false);
+                await compilationChecksums.FindAsync(solution.CompilationState, projectCone, assetHint: AssetHint.None, Flatten(compilationChecksums), map, cancellationToken).ConfigureAwait(false);
 
                 foreach (var frozenSourceGeneratedDocumentState in solution.CompilationState.FrozenSourceGeneratedDocumentStates?.States.Values ?? [])
                 {
                     var documentChecksums = await frozenSourceGeneratedDocumentState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
-                    await compilationChecksums.FindAsync(solution.CompilationState, assetHint: AssetHint.None, Flatten(documentChecksums), map, cancellationToken).ConfigureAwait(false);
+                    await compilationChecksums.FindAsync(solution.CompilationState, projectCone, assetHint: AssetHint.None, Flatten(documentChecksums), map, cancellationToken).ConfigureAwait(false);
                 }
 
                 var solutionChecksums = await solution.CompilationState.SolutionState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
-                await solutionChecksums.FindAsync(solution.CompilationState.SolutionState, assetHint: AssetHint.None, Flatten(solutionChecksums), map, cancellationToken).ConfigureAwait(false);
+                await solutionChecksums.FindAsync(solution.CompilationState.SolutionState, projectCone, assetHint: AssetHint.None, Flatten(solutionChecksums), map, cancellationToken).ConfigureAwait(false);
 
                 foreach (var project in solution.Projects)
                     await project.AppendAssetMapAsync(map, cancellationToken).ConfigureAwait(false);
             }
             else
             {
+                var projectId = projectCone.Value.RootProjectId;
                 var compilationChecksums = await solution.CompilationState.GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
-                await compilationChecksums.FindAsync(solution.CompilationState, assetHint: projectId, Flatten(compilationChecksums), map, cancellationToken).ConfigureAwait(false);
+                await compilationChecksums.checksums.FindAsync(solution.CompilationState, projectCone, assetHint: projectId, Flatten(compilationChecksums.checksums), map, cancellationToken).ConfigureAwait(false);
 
                 var solutionChecksums = await solution.CompilationState.SolutionState.GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
-                await solutionChecksums.FindAsync(solution.CompilationState.SolutionState, assetHint: projectId, Flatten(solutionChecksums), map, cancellationToken).ConfigureAwait(false);
+                await solutionChecksums.checksums.FindAsync(solution.CompilationState.SolutionState, projectCone, assetHint: projectId, Flatten(solutionChecksums.checksums), map, cancellationToken).ConfigureAwait(false);
 
                 var project = solution.GetRequiredProject(projectId);
                 await project.AppendAssetMapAsync(map, cancellationToken).ConfigureAwait(false);

From 42752cf93286b4c21bdbdebfc86b6d444f4744f5 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 11:58:04 -0700
Subject: [PATCH 018/170] undo

---
 .../SolutionCompilationState_Checksum.cs      | 19 +++++++++++--------
 .../Remote/ServiceHub/Host/TestUtils.cs       | 18 +++++++++---------
 2 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
index b7872fa8ee440..e14a944deac40 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
@@ -14,16 +14,19 @@
 
 namespace Microsoft.CodeAnalysis;
 
-internal readonly struct ProjectCone
+internal readonly struct ProjectCone(ProjectId rootProjectId, IReadOnlySet<ProjectId> projectIds) : IEquatable<ProjectCone>
 {
-    public readonly ProjectId RootProjectId;
-    public readonly IReadOnlySet<ProjectId> ProjectIds;
+    public readonly ProjectId RootProjectId = rootProjectId;
+    public readonly IReadOnlySet<ProjectId> ProjectIds = projectIds;
 
-    public ProjectCone(ProjectId rootProjectId, IReadOnlySet<ProjectId> projectIds)
-    {
-        RootProjectId = rootProjectId;
-        ProjectIds = projectIds;
-    }
+    public override bool Equals(object obj)
+        => obj is ProjectCone cone && Equals(cone);
+
+    public bool Equals(ProjectCone other)
+        => this.RootProjectId == other.RootProjectId && this.ProjectIds.SetEquals(other.ProjectIds);
+
+    public override int GetHashCode()
+        => throw new NotImplementedException();
 }
 
 internal partial class SolutionCompilationState
diff --git a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
index b124eceb4bfba..713e1bd9b854c 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
@@ -189,35 +189,35 @@ public static async Task<Dictionary<Checksum, object>> GetAssetMapAsync(this Pro
         }
 
         public static Task AppendAssetMapAsync(this Solution solution, Dictionary<Checksum, object> map, CancellationToken cancellationToken)
-            => AppendAssetMapAsync(solution, projectCone: null, map, cancellationToken);
+            => AppendAssetMapAsync(solution, map, projectId: null, cancellationToken);
 
         public static async Task AppendAssetMapAsync(
-            this Solution solution, ProjectCone? projectCone, Dictionary<Checksum, object> map, CancellationToken cancellationToken)
+            this Solution solution, Dictionary<Checksum, object> map, ProjectId? projectId, CancellationToken cancellationToken)
         {
-            if (projectCone == null)
+            if (projectId == null)
             {
                 var compilationChecksums = await solution.CompilationState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
-                await compilationChecksums.FindAsync(solution.CompilationState, projectCone, assetHint: AssetHint.None, Flatten(compilationChecksums), map, cancellationToken).ConfigureAwait(false);
+                await compilationChecksums.FindAsync(solution.CompilationState, projectCone: null, assetHint: AssetHint.None, Flatten(compilationChecksums), map, cancellationToken).ConfigureAwait(false);
 
                 foreach (var frozenSourceGeneratedDocumentState in solution.CompilationState.FrozenSourceGeneratedDocumentStates?.States.Values ?? [])
                 {
                     var documentChecksums = await frozenSourceGeneratedDocumentState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
-                    await compilationChecksums.FindAsync(solution.CompilationState, projectCone, assetHint: AssetHint.None, Flatten(documentChecksums), map, cancellationToken).ConfigureAwait(false);
+                    await compilationChecksums.FindAsync(solution.CompilationState, projectCone: null, assetHint: AssetHint.None, Flatten(documentChecksums), map, cancellationToken).ConfigureAwait(false);
                 }
 
                 var solutionChecksums = await solution.CompilationState.SolutionState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
-                await solutionChecksums.FindAsync(solution.CompilationState.SolutionState, projectCone, assetHint: AssetHint.None, Flatten(solutionChecksums), map, cancellationToken).ConfigureAwait(false);
+                await solutionChecksums.FindAsync(solution.CompilationState.SolutionState, projectCone: null, assetHint: AssetHint.None, Flatten(solutionChecksums), map, cancellationToken).ConfigureAwait(false);
 
                 foreach (var project in solution.Projects)
                     await project.AppendAssetMapAsync(map, cancellationToken).ConfigureAwait(false);
             }
             else
             {
-                var projectId = projectCone.Value.RootProjectId;
-                var compilationChecksums = await solution.CompilationState.GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
-                await compilationChecksums.checksums.FindAsync(solution.CompilationState, projectCone, assetHint: projectId, Flatten(compilationChecksums.checksums), map, cancellationToken).ConfigureAwait(false);
+                var (compilationChecksums, projectCone) = await solution.CompilationState.GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
+                await compilationChecksums.FindAsync(solution.CompilationState, projectCone, assetHint: projectId, Flatten(compilationChecksums), map, cancellationToken).ConfigureAwait(false);
 
                 var solutionChecksums = await solution.CompilationState.SolutionState.GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
+                Contract.ThrowIfFalse(projectCone.Equals(solutionChecksums.projectCone));
                 await solutionChecksums.checksums.FindAsync(solution.CompilationState.SolutionState, projectCone, assetHint: projectId, Flatten(solutionChecksums.checksums), map, cancellationToken).ConfigureAwait(false);
 
                 var project = solution.GetRequiredProject(projectId);

From 643cd2f5153024970799053737312b220582bd3a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:15:30 -0700
Subject: [PATCH 019/170] fix

---
 .../Workspace/Solution/SolutionCompilationState_Checksum.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
index e14a944deac40..35a771497900d 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
@@ -60,7 +60,7 @@ public bool TryGetStateChecksums(ProjectId projectId, [NotNullWhen(true)] out So
             }
         }
 
-        if (lazyChecksums.TryGetValue(out var checksumsAndCone))
+        if (!lazyChecksums.TryGetValue(out var checksumsAndCone))
         {
             stateChecksums = null;
             return false;

From 931f7848bc8be63f68fac5bbd89da32baa4528ea Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:16:18 -0700
Subject: [PATCH 020/170] fix

---
 .../Core/Portable/Workspace/Solution/SolutionState_Checksum.cs  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index fa278cd606deb..700bfffe51db0 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -54,7 +54,7 @@ public bool TryGetStateChecksums(ProjectId projectId, [NotNullWhen(true)] out So
             }
         }
 
-        if (lazyChecksums.TryGetValue(out var checksumsAndProjectCone))
+        if (!lazyChecksums.TryGetValue(out var checksumsAndProjectCone))
         {
             stateChecksums = null;
             return false;

From b10a170cebe53af40297ac7bf4b75176ee89cdf5 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:25:51 -0700
Subject: [PATCH 021/170] Simplify

---
 .../Core/Portable/Workspace/Solution/SolutionState_Checksum.cs  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index 700bfffe51db0..ec3a957621f19 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -135,7 +135,7 @@ public async Task<Checksum> GetChecksumAsync(ProjectId projectId, CancellationTo
                     if (!RemoteSupportedLanguages.IsSupported(projectState.Language))
                         continue;
 
-                    if (projectConeId != null && !projectConeSet!.Contains(orderedProjectId))
+                    if (projectConeSet != null && !projectConeSet.Contains(orderedProjectId))
                         continue;
 
                     projectChecksumTasks.Add(projectState.GetStateChecksumsAsync(cancellationToken));

From 22521fca089899432d55cda8b2a7890fb6202bbd Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:49:09 -0700
Subject: [PATCH 022/170] Extract file

---
 .../Workspace/Solution/ProjectCone.cs         | 35 +++++++++++++++++++
 .../SolutionCompilationState_Checksum.cs      | 15 --------
 2 files changed, 35 insertions(+), 15 deletions(-)
 create mode 100644 src/Workspaces/Core/Portable/Workspace/Solution/ProjectCone.cs

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectCone.cs b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectCone.cs
new file mode 100644
index 0000000000000..a3ee4dfe6976d
--- /dev/null
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectCone.cs
@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Frozen;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis;
+
+/// <summary>
+/// Represents a 'cone' of projects that is being sync'ed between the local and remote hosts.  A project cone starts
+/// with a <see cref="RootProjectId"/>, and contains both it and all dependent projects within <see cref="ProjectIds"/>.
+/// </summary>
+internal sealed class ProjectCone : IEquatable<ProjectCone>
+{
+    public readonly ProjectId RootProjectId;
+    public readonly FrozenSet<ProjectId> ProjectIds;
+
+    public ProjectCone(ProjectId rootProjectId, FrozenSet<ProjectId> projectIds)
+    {
+        Contract.ThrowIfFalse(projectIds.Contains(rootProjectId));
+        RootProjectId = rootProjectId;
+        ProjectIds = projectIds;
+    }
+
+    public override bool Equals(object? obj)
+        => obj is ProjectCone cone && Equals(cone);
+
+    public bool Equals(ProjectCone? other)
+        => other is not null && this.RootProjectId == other.RootProjectId && this.ProjectIds.SetEquals(other.ProjectIds);
+
+    public override int GetHashCode()
+        => throw new NotImplementedException();
+}
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
index 8f61614448423..79d8e7ec11b65 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
@@ -15,21 +15,6 @@
 
 namespace Microsoft.CodeAnalysis;
 
-internal sealed class ProjectCone(ProjectId rootProjectId, FrozenSet<ProjectId> projectIds) : IEquatable<ProjectCone>
-{
-    public readonly ProjectId RootProjectId = rootProjectId;
-    public readonly FrozenSet<ProjectId> ProjectIds = projectIds;
-
-    public override bool Equals(object? obj)
-        => obj is ProjectCone cone && Equals(cone);
-
-    public bool Equals(ProjectCone? other)
-        => other is not null && this.RootProjectId == other.RootProjectId && this.ProjectIds.SetEquals(other.ProjectIds);
-
-    public override int GetHashCode()
-        => throw new NotImplementedException();
-}
-
 internal partial class SolutionCompilationState
 {
     /// <summary>

From 2f82a01fe58459e900e95b18432f1051c6259560 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:51:52 -0700
Subject: [PATCH 023/170] Add assert

---
 .../Workspace/Solution/SolutionState_Checksum.cs | 16 ++++++++++++----
 .../Remote/Core/SolutionAssetStorage.Scope.cs    |  2 +-
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index 9af209a225472..4173fb80f2bf1 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Frozen;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
@@ -102,7 +103,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
         ProjectId? projectConeId,
         CancellationToken cancellationToken)
     {
-        using var _1 = PooledHashSet<ProjectId>.GetInstance(out var projectCone);
+        using var _1 = PooledHashSet<ProjectId>.GetInstance(out var projectConeSet);
         AddProjectCone(projectConeId);
 
         try
@@ -121,7 +122,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                     if (!RemoteSupportedLanguages.IsSupported(projectState.Language))
                         continue;
 
-                    if (projectConeId != null && !projectCone.Contains(orderedProjectId))
+                    if (projectConeId != null && !projectConeSet.Contains(orderedProjectId))
                         continue;
 
                     projectChecksumTasks.Add(projectState.GetStateChecksumsAsync(cancellationToken));
@@ -135,11 +136,18 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                 var analyzerReferenceChecksums = ChecksumCache.GetOrCreateChecksumCollection(
                     this.AnalyzerReferences, this.Services.GetRequiredService<ISerializerService>(), cancellationToken);
 
-                return new SolutionStateChecksums(
+                var stateChecksums = new SolutionStateChecksums(
                     projectConeId,
                     this.SolutionAttributes.Checksum,
                     new(new ChecksumCollection(projectChecksums), projectIds),
                     analyzerReferenceChecksums);
+
+#if DEBUG
+                var projectCone = projectConeId is null ? null : new ProjectCone(projectConeId, projectConeSet.ToFrozenSet());
+                RoslynDebug.Assert(Equals(projectCone, stateChecksums.ProjectCone));
+#endif
+
+                return stateChecksums;
             }
         }
         catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e, cancellationToken))
@@ -152,7 +160,7 @@ void AddProjectCone(ProjectId? projectConeId)
             if (projectConeId is null)
                 return;
 
-            if (!projectCone.Add(projectConeId))
+            if (!projectConeSet.Add(projectConeId))
                 return;
 
             var projectState = this.GetProjectState(projectConeId);
diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
index d8b59a0670f12..a87a15de4cfcb 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
@@ -80,7 +80,7 @@ private async Task FindAssetsAsync(
             else
             {
                 // Otherwise, grab the top-most state checksum for this cone and search within that.
-                Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(this.ProjectCone.Value.RootProjectId, out var stateChecksums));
+                Contract.ThrowIfFalse(solutionState.TryGetStateChecksums(this.ProjectCone.RootProjectId, out var stateChecksums));
                 await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetHint, remainingChecksumsToFind, result, cancellationToken).ConfigureAwait(false);
             }
         }

From 5ac9b68cdf206f177e14e6eb1d95f2225d811515 Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <Maryam.Ariyan@microsoft.com>
Date: Tue, 12 Mar 2024 12:52:18 -0700
Subject: [PATCH 024/170] Apply PR feedback

- Rename option to be `RazorSourceGenerator`
- Cache results in analyzer provider, since result is fixed per roslyn instance
- Remove duped names taken out of ProjectSystemProject
---
 .../LanguageServerTestComposition.cs          |  2 +-
 .../HostDiagnosticAnalyzerProvider.cs         | 46 ++++++++-----------
 .../LanguageServerWorkspaceFactory.cs         |  4 +-
 .../Program.cs                                | 10 ++--
 .../ServerConfigurationFactory.cs             |  2 +-
 .../ProjectSystem/ProjectSystemProject.cs     |  2 +-
 6 files changed, 29 insertions(+), 37 deletions(-)

diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
index 3422dc1c30a16..fab6370f9f30d 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
@@ -32,7 +32,7 @@ public static Task<ExportProvider> CreateExportProviderAsync(ILoggerFactory logg
             SessionId: null,
             ExtensionAssemblyPaths: [],
             DevKitDependencyPath: devKitDependencyPath,
-            DevKitRazorOutputPath: null,
+            RazorSourceGenerator: null,
             ExtensionLogDirectory: string.Empty);
         var extensionAssemblyManager = ExtensionAssemblyManager.Create(serverConfiguration, loggerFactory);
         return ExportProviderBuilder.CreateExportProviderAsync(extensionAssemblyManager, devKitDependencyPath, loggerFactory: loggerFactory);
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
index 517275e99ad9a..dabf29f8ba48e 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
@@ -12,48 +12,40 @@ namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 internal class HostDiagnosticAnalyzerProvider : IHostDiagnosticAnalyzerProvider
 {
     /// <summary>
-    /// The directory where the analyzers are located
+    /// The full path to the Razor source generator
     /// </summary>
-    public string? AnalyzerDirectory { get; set; }
+    public string? RazorSourceGenerator { get; set; }
 
-    private const string RazorVsixExtensionId = "Microsoft.VisualStudio.RazorExtension";
-    private static readonly HashSet<string> s_razorSourceGeneratorAssemblyNames = new[] {
-        "Microsoft.NET.Sdk.Razor.SourceGenerators",
-        "Microsoft.CodeAnalysis.Razor.Compiler.SourceGenerators",
-        "Microsoft.CodeAnalysis.Razor.Compiler",
-    }.ToHashSet<string>();
+    private ImmutableArray<(AnalyzerFileReference reference, string extensionId)>? _cachedAnalyzerReferences;
 
-    public HostDiagnosticAnalyzerProvider(string? analyzerDirectory)
+    public HostDiagnosticAnalyzerProvider(string? razorSourceGenerator)
     {
-        AnalyzerDirectory = analyzerDirectory;
+        RazorSourceGenerator = razorSourceGenerator;
     }
 
     public ImmutableArray<(AnalyzerFileReference reference, string extensionId)> GetAnalyzerReferencesInExtensions()
     {
-        if (AnalyzerDirectory == null)
+        if (_cachedAnalyzerReferences != null)
         {
-            return ImmutableArray<(AnalyzerFileReference reference, string extensionId)>.Empty;
+            return _cachedAnalyzerReferences.Value;
         }
 
-        var analyzerReferences = new List<(AnalyzerFileReference, string)>();
+        if (RazorSourceGenerator == null)
+        {
+            _cachedAnalyzerReferences = ImmutableArray<(AnalyzerFileReference reference, string extensionId)>.Empty;
+            return _cachedAnalyzerReferences.Value;
+        }
 
-        // Get all the .dll files in the directory
-        var analyzerFiles = Directory.GetFiles(AnalyzerDirectory, "*.dll");
+        var analyzerReferences = new List<(AnalyzerFileReference, string)>();
 
-        foreach (var analyzerFile in analyzerFiles)
-        {
-            // Create an AnalyzerFileReference for each file
-            var analyzerReference = new AnalyzerFileReference(analyzerFile, new SimpleAnalyzerAssemblyLoader());
+        // Create an AnalyzerFileReference for each file
+        var analyzerReference = new AnalyzerFileReference(RazorSourceGenerator, new SimpleAnalyzerAssemblyLoader());
 
-            if (s_razorSourceGeneratorAssemblyNames.Any(
-                name => analyzerReference.FullPath.Contains(name, StringComparison.OrdinalIgnoreCase)))
-            {
-                // Add the reference to the list, using the file name as the extension ID
-                analyzerReferences.Add((analyzerReference, RazorVsixExtensionId));
-            }
-        }
+        // Add the reference to the list, using the file name as the extension ID
+        analyzerReferences.Add((analyzerReference, ProjectSystemProject.RazorVsixExtensionId));
 
-        return analyzerReferences.ToImmutableArray();
+        _cachedAnalyzerReferences = analyzerReferences.ToImmutableArray();
+        return _cachedAnalyzerReferences.Value;
     }
 
     private class SimpleAnalyzerAssemblyLoader : IAnalyzerAssemblyLoader
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs
index 82055c4c58a46..3936424280067 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs
@@ -41,11 +41,11 @@ public LanguageServerWorkspaceFactory(
 
         analyzerLoader.InitializeDiagnosticsServices(Workspace);
 
-        var devKitRazorOutputPath = serverConfigurationFactory?.ServerConfiguration?.DevKitRazorOutputPath;
+        var razorSourceGenerator = serverConfigurationFactory?.ServerConfiguration?.RazorSourceGenerator;
         ProjectSystemHostInfo = new ProjectSystemHostInfo(
             DynamicFileInfoProviders: dynamicFileInfoProviders.ToImmutableArray(),
             new ProjectSystemDiagnosticSource(),
-            new HostDiagnosticAnalyzerProvider(devKitRazorOutputPath));
+            new HostDiagnosticAnalyzerProvider(razorSourceGenerator));
 
         TargetFrameworkManager = projectTargetFrameworkManager;
     }
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
index ebd2790dc7441..56a0a041edd55 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
@@ -198,9 +198,9 @@ static CliRootCommand CreateCommandLineParser()
         Required = false
     };
 
-    var devKitRazorOutputPathOption = new CliOption<string?>("--devKitRazorOutputPath")
+    var razorSourceGeneratorOption = new CliOption<string?>("--razorSourceGenerator")
     {
-        Description = "Full path to the Razor output path used with DevKit (optional).",
+        Description = "Full path to the Razor source generator (optional).",
         Required = false
     };
 
@@ -214,7 +214,7 @@ static CliRootCommand CreateCommandLineParser()
         sessionIdOption,
         extensionAssemblyPathsOption,
         devKitDependencyPathOption,
-        devKitRazorOutputPathOption,
+        razorSourceGeneratorOption,
         extensionLogDirectoryOption
     };
     rootCommand.SetAction((parseResult, cancellationToken) =>
@@ -226,7 +226,7 @@ static CliRootCommand CreateCommandLineParser()
         var sessionId = parseResult.GetValue(sessionIdOption);
         var extensionAssemblyPaths = parseResult.GetValue(extensionAssemblyPathsOption) ?? [];
         var devKitDependencyPath = parseResult.GetValue(devKitDependencyPathOption);
-        var devKitRazorOutputPath = parseResult.GetValue(devKitRazorOutputPathOption);
+        var razorSourceGenerator = parseResult.GetValue(razorSourceGeneratorOption);
         var extensionLogDirectory = parseResult.GetValue(extensionLogDirectoryOption)!;
 
         var serverConfiguration = new ServerConfiguration(
@@ -237,7 +237,7 @@ static CliRootCommand CreateCommandLineParser()
             SessionId: sessionId,
             ExtensionAssemblyPaths: extensionAssemblyPaths,
             DevKitDependencyPath: devKitDependencyPath,
-            DevKitRazorOutputPath: devKitRazorOutputPath,
+            RazorSourceGenerator: razorSourceGenerator,
             ExtensionLogDirectory: extensionLogDirectory);
 
         return RunAsync(serverConfiguration, cancellationToken);
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs
index ce7496dd8d9f7..f95acef7d3f83 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs
@@ -49,5 +49,5 @@ internal record class ServerConfiguration(
     string? SessionId,
     IEnumerable<string> ExtensionAssemblyPaths,
     string? DevKitDependencyPath,
-    string? DevKitRazorOutputPath,
+    string? RazorSourceGenerator,
     string ExtensionLogDirectory);
diff --git a/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs b/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs
index 9e900ceeaf494..fd6599b2c1565 100644
--- a/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs
+++ b/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs
@@ -989,7 +989,7 @@ public void RemoveAnalyzerReference(string fullPath)
         }
     }
 
-    private const string RazorVsixExtensionId = "Microsoft.VisualStudio.RazorExtension";
+    internal const string RazorVsixExtensionId = "Microsoft.VisualStudio.RazorExtension";
     private static readonly string s_razorSourceGeneratorSdkDirectory = Path.Combine("Sdks", "Microsoft.NET.Sdk.Razor", "source-generators") + PathUtilities.DirectorySeparatorStr;
     private static readonly ImmutableArray<string> s_razorSourceGeneratorAssemblyNames =
     [

From 32904a752ecc532f89e87faf7e11bd49469153dc Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:55:07 -0700
Subject: [PATCH 025/170] Add assert

---
 src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
index 713e1bd9b854c..b5904468664f6 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
@@ -217,8 +217,8 @@ public static async Task AppendAssetMapAsync(
                 await compilationChecksums.FindAsync(solution.CompilationState, projectCone, assetHint: projectId, Flatten(compilationChecksums), map, cancellationToken).ConfigureAwait(false);
 
                 var solutionChecksums = await solution.CompilationState.SolutionState.GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
-                Contract.ThrowIfFalse(projectCone.Equals(solutionChecksums.projectCone));
-                await solutionChecksums.checksums.FindAsync(solution.CompilationState.SolutionState, projectCone, assetHint: projectId, Flatten(solutionChecksums.checksums), map, cancellationToken).ConfigureAwait(false);
+                Contract.ThrowIfFalse(projectCone.Equals(solutionChecksums.ProjectCone));
+                await solutionChecksums.FindAsync(solution.CompilationState.SolutionState, projectCone, assetHint: projectId, Flatten(solutionChecksums), map, cancellationToken).ConfigureAwait(false);
 
                 var project = solution.GetRequiredProject(projectId);
                 await project.AppendAssetMapAsync(map, cancellationToken).ConfigureAwait(false);

From 79d4a49c1cb2f59e28148ed07625dc5585573c89 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:55:42 -0700
Subject: [PATCH 026/170] Add assert

---
 src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
index b5904468664f6..e942c5e44f5fd 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/TestUtils.cs
@@ -206,6 +206,7 @@ public static async Task AppendAssetMapAsync(
                 }
 
                 var solutionChecksums = await solution.CompilationState.SolutionState.GetStateChecksumsAsync(cancellationToken).ConfigureAwait(false);
+                Contract.ThrowIfTrue(solutionChecksums.ProjectCone != null);
                 await solutionChecksums.FindAsync(solution.CompilationState.SolutionState, projectCone: null, assetHint: AssetHint.None, Flatten(solutionChecksums), map, cancellationToken).ConfigureAwait(false);
 
                 foreach (var project in solution.Projects)

From 9c8996b2613664c049ae5a70cba3986ab06688a6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:57:56 -0700
Subject: [PATCH 027/170] Revert

---
 .../Core/Portable/Workspace/Solution/SolutionState.cs         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
index 2dbf12c4c1259..3e6200977dde5 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState.cs
@@ -74,8 +74,8 @@ private SolutionState(
         _lazyAnalyzers = lazyAnalyzers ?? CreateLazyHostDiagnosticAnalyzers(analyzerReferences);
 
         // when solution state is changed, we recalculate its checksum
-        _lazyChecksums = AsyncLazy.Create(
-            static (self, cancellationToken) => self.ComputeChecksumsAsync(projectConeId: null, cancellationToken),
+        _lazyChecksums = AsyncLazy.Create(static (self, c) =>
+            self.ComputeChecksumsAsync(projectConeId: null, c),
             arg: this);
 
         CheckInvariants();

From 417449896590a7b79347a9a740b26abf06906f56 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:58:32 -0700
Subject: [PATCH 028/170] Revert

---
 .../Portable/Workspace/Solution/SolutionState_Checksum.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index 4173fb80f2bf1..08594d36138f5 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -44,18 +44,18 @@ public bool TryGetStateChecksums([NotNullWhen(true)] out SolutionStateChecksums?
 
     public bool TryGetStateChecksums(ProjectId projectId, [NotNullWhen(true)] out SolutionStateChecksums? stateChecksums)
     {
-        AsyncLazy<SolutionStateChecksums>? lazyChecksums;
+        AsyncLazy<SolutionStateChecksums>? checksums;
         lock (_lazyProjectChecksums)
         {
-            if (!_lazyProjectChecksums.TryGetValue(projectId, out lazyChecksums) ||
-                lazyChecksums == null)
+            if (!_lazyProjectChecksums.TryGetValue(projectId, out checksums) ||
+                checksums == null)
             {
                 stateChecksums = null;
                 return false;
             }
         }
 
-        return lazyChecksums.TryGetValue(out stateChecksums);
+        return checksums.TryGetValue(out stateChecksums);
     }
 
     public Task<SolutionStateChecksums> GetStateChecksumsAsync(CancellationToken cancellationToken)

From 60810f36d97745e77cd6e156c4373960662a45f2 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:58:51 -0700
Subject: [PATCH 029/170] Revert

---
 .../Portable/Workspace/Solution/SolutionState_Checksum.cs     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index 08594d36138f5..5ca0e8621deba 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -93,8 +93,8 @@ public async Task<SolutionStateChecksums> GetStateChecksumsAsync(
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
     public async Task<Checksum> GetChecksumAsync(ProjectId projectId, CancellationToken cancellationToken)
     {
-        var stateChecksums = await GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
-        return stateChecksums.Checksum;
+        var checksums = await GetStateChecksumsAsync(projectId, cancellationToken).ConfigureAwait(false);
+        return checksums.Checksum;
     }
 
     /// <param name="projectConeId">Cone of projects to compute a checksum for.  Pass in <see langword="null"/> to get a

From 615b6e91c96704a15c2c9d7aefdd97c4a97143c5 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 12:59:35 -0700
Subject: [PATCH 030/170] Revert

---
 .../Workspace/Solution/SolutionState_Checksum.cs       | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index 5ca0e8621deba..da9625f54a0c1 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -103,7 +103,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
         ProjectId? projectConeId,
         CancellationToken cancellationToken)
     {
-        using var _1 = PooledHashSet<ProjectId>.GetInstance(out var projectConeSet);
+        using var projectConeSet = SharedPools.Default<HashSet<ProjectId>>().GetPooledObject();
         AddProjectCone(projectConeId);
 
         try
@@ -114,7 +114,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                 // requested set of projects if applicable.
                 var orderedProjectIds = GetOrCreateSortedProjectIds(this.ProjectIds);
 
-                using var _2 = ArrayBuilder<Task<ProjectStateChecksums>>.GetInstance(out var projectChecksumTasks);
+                using var _ = ArrayBuilder<Task<ProjectStateChecksums>>.GetInstance(out var projectChecksumTasks);
 
                 foreach (var orderedProjectId in orderedProjectIds)
                 {
@@ -122,7 +122,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                     if (!RemoteSupportedLanguages.IsSupported(projectState.Language))
                         continue;
 
-                    if (projectConeId != null && !projectConeSet.Contains(orderedProjectId))
+                    if (projectConeId != null && !projectConeSet.Object.Contains(orderedProjectId))
                         continue;
 
                     projectChecksumTasks.Add(projectState.GetStateChecksumsAsync(cancellationToken));
@@ -143,7 +143,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                     analyzerReferenceChecksums);
 
 #if DEBUG
-                var projectCone = projectConeId is null ? null : new ProjectCone(projectConeId, projectConeSet.ToFrozenSet());
+                var projectCone = projectConeId is null ? null : new ProjectCone(projectConeId, projectConeSet.Object.ToFrozenSet());
                 RoslynDebug.Assert(Equals(projectCone, stateChecksums.ProjectCone));
 #endif
 
@@ -160,7 +160,7 @@ void AddProjectCone(ProjectId? projectConeId)
             if (projectConeId is null)
                 return;
 
-            if (!projectConeSet.Add(projectConeId))
+            if (!projectConeSet.Object.Add(projectConeId))
                 return;
 
             var projectState = this.GetProjectState(projectConeId);

From 0aa9398ea5ca52df11865ee447284c9ce4b2dc06 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 13:01:10 -0700
Subject: [PATCH 031/170] Revert

---
 .../Solution/SolutionCompilationState_Checksum.cs      | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
index 79d8e7ec11b65..ac99345a0b998 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
@@ -67,24 +67,24 @@ public async Task<Checksum> GetChecksumAsync(CancellationToken cancellationToken
 
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
     public async Task<(SolutionCompilationStateChecksums checksums, ProjectCone projectCone)> GetStateChecksumsAsync(
-        ProjectId projectConeId,
+        ProjectId projectId,
         CancellationToken cancellationToken)
     {
-        Contract.ThrowIfNull(projectConeId);
+        Contract.ThrowIfNull(projectId);
 
         AsyncLazy<(SolutionCompilationStateChecksums checksums, ProjectCone projectCone)>? checksums;
         lock (_lazyProjectChecksums)
         {
-            if (!_lazyProjectChecksums.TryGetValue(projectConeId, out checksums))
+            if (!_lazyProjectChecksums.TryGetValue(projectId, out checksums))
             {
                 checksums = AsyncLazy.Create(static async (arg, cancellationToken) =>
                 {
                     var (checksum, projectCone) = await arg.self.ComputeChecksumsAsync(arg.projectConeId, cancellationToken).ConfigureAwait(false);
                     Contract.ThrowIfNull(projectCone);
                     return (checksum, projectCone);
-                }, arg: (self: this, projectConeId));
+                }, arg: (self: this, projectId));
 
-                _lazyProjectChecksums.Add(projectConeId, checksums);
+                _lazyProjectChecksums.Add(projectId, checksums);
             }
         }
 

From 7dc12fa46f6e3305b0e47b689910c12b85680609 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 13:01:54 -0700
Subject: [PATCH 032/170] Revert

---
 .../Workspace/Solution/SolutionState_Checksum.cs       | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index da9625f54a0c1..bddb8685dc33f 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -69,20 +69,20 @@ public async Task<Checksum> GetChecksumAsync(CancellationToken cancellationToken
 
     /// <summary>Gets the checksum for only the requested project (and any project it depends on)</summary>
     public async Task<SolutionStateChecksums> GetStateChecksumsAsync(
-        ProjectId projectConeId,
+        ProjectId projectId,
         CancellationToken cancellationToken)
     {
-        Contract.ThrowIfNull(projectConeId);
+        Contract.ThrowIfNull(projectId);
 
         AsyncLazy<SolutionStateChecksums>? checksums;
         lock (_lazyProjectChecksums)
         {
-            if (!_lazyProjectChecksums.TryGetValue(projectConeId, out checksums))
+            if (!_lazyProjectChecksums.TryGetValue(projectId, out checksums))
             {
                 checksums = AsyncLazy.Create(
                     static (arg, cancellationToken) => arg.self.ComputeChecksumsAsync(arg.projectConeId, cancellationToken),
-                    arg: (self: this, projectConeId));
-                _lazyProjectChecksums.Add(projectConeId, checksums);
+                    arg: (self: this, projectId));
+                _lazyProjectChecksums.Add(projectId, checksums);
             }
         }
 

From 15e75cf5ed063311ea3c463bef9b6a969eeceae6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 13:02:40 -0700
Subject: [PATCH 033/170] Revert

---
 .../Workspace/Solution/SolutionState_Checksum.cs       | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index bddb8685dc33f..c2643951f6382 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -103,7 +103,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
         ProjectId? projectConeId,
         CancellationToken cancellationToken)
     {
-        using var projectConeSet = SharedPools.Default<HashSet<ProjectId>>().GetPooledObject();
+        using var projectCone = SharedPools.Default<HashSet<ProjectId>>().GetPooledObject();
         AddProjectCone(projectConeId);
 
         try
@@ -122,7 +122,7 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                     if (!RemoteSupportedLanguages.IsSupported(projectState.Language))
                         continue;
 
-                    if (projectConeId != null && !projectConeSet.Object.Contains(orderedProjectId))
+                    if (projectConeId != null && !projectCone.Object.Contains(orderedProjectId))
                         continue;
 
                     projectChecksumTasks.Add(projectState.GetStateChecksumsAsync(cancellationToken));
@@ -143,8 +143,8 @@ private async Task<SolutionStateChecksums> ComputeChecksumsAsync(
                     analyzerReferenceChecksums);
 
 #if DEBUG
-                var projectCone = projectConeId is null ? null : new ProjectCone(projectConeId, projectConeSet.Object.ToFrozenSet());
-                RoslynDebug.Assert(Equals(projectCone, stateChecksums.ProjectCone));
+                var projectConeTemp = projectConeId is null ? null : new ProjectCone(projectConeId, projectCone.Object.ToFrozenSet());
+                RoslynDebug.Assert(Equals(projectConeTemp, stateChecksums.ProjectCone));
 #endif
 
                 return stateChecksums;
@@ -160,7 +160,7 @@ void AddProjectCone(ProjectId? projectConeId)
             if (projectConeId is null)
                 return;
 
-            if (!projectConeSet.Object.Add(projectConeId))
+            if (!projectCone.Object.Add(projectConeId))
                 return;
 
             var projectState = this.GetProjectState(projectConeId);

From 175874f2fe9dac3038821d403f964365c507a6d4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 13:03:00 -0700
Subject: [PATCH 034/170] Revert

---
 .../Workspace/Solution/SolutionCompilationState_Checksum.cs     | 2 +-
 .../Core/Portable/Workspace/Solution/SolutionState_Checksum.cs  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
index ac99345a0b998..e3e503ce3836b 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
@@ -79,7 +79,7 @@ public async Task<Checksum> GetChecksumAsync(CancellationToken cancellationToken
             {
                 checksums = AsyncLazy.Create(static async (arg, cancellationToken) =>
                 {
-                    var (checksum, projectCone) = await arg.self.ComputeChecksumsAsync(arg.projectConeId, cancellationToken).ConfigureAwait(false);
+                    var (checksum, projectCone) = await arg.self.ComputeChecksumsAsync(arg.projectId, cancellationToken).ConfigureAwait(false);
                     Contract.ThrowIfNull(projectCone);
                     return (checksum, projectCone);
                 }, arg: (self: this, projectId));
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
index c2643951f6382..d6d21282fd084 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionState_Checksum.cs
@@ -80,7 +80,7 @@ public async Task<SolutionStateChecksums> GetStateChecksumsAsync(
             if (!_lazyProjectChecksums.TryGetValue(projectId, out checksums))
             {
                 checksums = AsyncLazy.Create(
-                    static (arg, cancellationToken) => arg.self.ComputeChecksumsAsync(arg.projectConeId, cancellationToken),
+                    static (arg, cancellationToken) => arg.self.ComputeChecksumsAsync(arg.projectId, cancellationToken),
                     arg: (self: this, projectId));
                 _lazyProjectChecksums.Add(projectId, checksums);
             }

From e63278f5ff4b2f11636f24c32401829ca9f00bf3 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 13:04:45 -0700
Subject: [PATCH 035/170] Comment

---
 .../Core/Portable/Workspace/Solution/StateChecksums.cs         | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs b/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
index 605d875812de2..e40c1fa3753b0 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
@@ -164,6 +164,9 @@ internal sealed class SolutionStateChecksums(
     public ChecksumsAndIds<ProjectId> Projects { get; } = projects;
     public ChecksumCollection AnalyzerReferences { get; } = analyzerReferences;
 
+    // Acceptably not threadsafe.  ProjectCone is a class, and the runtime guarantees anyone will see this field fully
+    // initialized.  It's acceptable to have multiple instances of this in a race condition as the data will be same
+    // (and our asserts don't check for reference equality, only value equality).
     public ProjectCone? ProjectCone => _projectCone ??= ComputeProjectCone();
 
     private ProjectCone? ComputeProjectCone()

From 5bb72183ec479edc39fc3689fac98b2e4645a8f6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 13:06:21 -0700
Subject: [PATCH 036/170] Simplify

---
 .../Core/Portable/Workspace/Solution/ProjectCone.cs   | 11 +++++++----
 .../Portable/Workspace/Solution/StateChecksums.cs     |  6 +++---
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectCone.cs b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectCone.cs
index a3ee4dfe6976d..8986e7b36129a 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/ProjectCone.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/ProjectCone.cs
@@ -10,25 +10,28 @@ namespace Microsoft.CodeAnalysis;
 
 /// <summary>
 /// Represents a 'cone' of projects that is being sync'ed between the local and remote hosts.  A project cone starts
-/// with a <see cref="RootProjectId"/>, and contains both it and all dependent projects within <see cref="ProjectIds"/>.
+/// with a <see cref="RootProjectId"/>, and contains both it and all dependent projects within <see cref="_projectIds"/>.
 /// </summary>
 internal sealed class ProjectCone : IEquatable<ProjectCone>
 {
     public readonly ProjectId RootProjectId;
-    public readonly FrozenSet<ProjectId> ProjectIds;
+    private readonly FrozenSet<ProjectId> _projectIds;
 
     public ProjectCone(ProjectId rootProjectId, FrozenSet<ProjectId> projectIds)
     {
         Contract.ThrowIfFalse(projectIds.Contains(rootProjectId));
         RootProjectId = rootProjectId;
-        ProjectIds = projectIds;
+        _projectIds = projectIds;
     }
 
+    public bool Contains(ProjectId projectId)
+        => _projectIds.Contains(projectId);
+
     public override bool Equals(object? obj)
         => obj is ProjectCone cone && Equals(cone);
 
     public bool Equals(ProjectCone? other)
-        => other is not null && this.RootProjectId == other.RootProjectId && this.ProjectIds.SetEquals(other.ProjectIds);
+        => other is not null && this.RootProjectId == other.RootProjectId && this._projectIds.SetEquals(other._projectIds);
 
     public override int GetHashCode()
         => throw new NotImplementedException();
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs b/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
index e40c1fa3753b0..e030b033f7275 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/StateChecksums.cs
@@ -232,7 +232,7 @@ public async Task FindAsync(
         if (assetHint.ProjectId != null)
         {
             Contract.ThrowIfTrue(
-                projectCone != null && !projectCone.ProjectIds.Contains(assetHint.ProjectId),
+                projectCone != null && !projectCone.Contains(assetHint.ProjectId),
                 "Requesting an asset outside of the cone explicitly being asked for!");
 
             var projectState = solution.GetProjectState(assetHint.ProjectId);
@@ -257,7 +257,7 @@ public async Task FindAsync(
 
                 // If we're syncing a project cone, no point at all at looking at child projects of the solution that
                 // are not in that cone.
-                if (projectCone != null && !projectCone.ProjectIds.Contains(projectId))
+                if (projectCone != null && !projectCone.Contains(projectId))
                     continue;
 
                 if (projectState.TryGetStateChecksums(out var projectStateChecksums) &&
@@ -276,7 +276,7 @@ public async Task FindAsync(
 
                 // If we're syncing a project cone, no point at all at looking at child projects of the solution that
                 // are not in that cone.
-                if (projectCone != null && !projectCone.ProjectIds.Contains(projectId))
+                if (projectCone != null && !projectCone.Contains(projectId))
                     continue;
 
                 // It's possible not all all our projects have checksums.  Specifically, we may have only been asked to

From 1a6275121640cc9d417c9c13ac5dcd9d5b3cf978 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 13:15:32 -0700
Subject: [PATCH 037/170] REmove

---
 .../Workspace/Solution/SolutionCompilationState_Checksum.cs      | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
index e3e503ce3836b..830d52cd72c3d 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState_Checksum.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Frozen;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;

From 8e506122b1c431509cbe990e6f2156ec6a5cdc6a Mon Sep 17 00:00:00 2001
From: sdelarosbil <sdelarosbil@spiria.com>
Date: Tue, 12 Mar 2024 16:33:28 -0400
Subject: [PATCH 038/170] Add a unit test to ensure object initialisers
 supports completion in collection expressions

---
 ...bjectInitializerCompletionProviderTests.cs | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ObjectInitializerCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ObjectInitializerCompletionProviderTests.cs
index 227666c5027ff..f30844e7267b3 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ObjectInitializerCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ObjectInitializerCompletionProviderTests.cs
@@ -185,6 +185,43 @@ void goo()
             await VerifyExclusiveAsync(markup, true);
         }
 
+        [Fact]
+        public async Task FieldAndProperty2()
+        {
+            var markup = """
+                public static class TestClass
+                {
+                    private static SimpleRange[] _ranges;
+                
+                    public static void Method()
+                    {
+                        _ranges =
+                        [
+                            new()
+                            {
+                                Start = 1,
+                                End = 3,
+                            },
+                            new()
+                            {
+                                $$
+                            },
+                        ];
+                    }
+                }
+                
+                public struct SimpleRange
+                {
+                    public int Start;
+                    public int End { get; set; }
+                };
+                """;
+
+            await VerifyItemExistsAsync(markup, "Start");
+            await VerifyItemExistsAsync(markup, "End");
+            await VerifyExclusiveAsync(markup, true);
+        }
+
         [Fact]
         public async Task HidePreviouslyTyped()
         {

From 70b4083f23ee1e74ca43e75a189da56f36702e68 Mon Sep 17 00:00:00 2001
From: AlekseyTs <AlekseyTs@users.noreply.github.com>
Date: Tue, 12 Mar 2024 15:02:42 -0700
Subject: [PATCH 039/170] Update Language Feature Status for Params Collections
 (#72516)

---
 docs/Language Feature Status.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md
index 456905c829ce6..b7651f0632ca6 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -11,7 +11,6 @@ efforts behind them.
 | Feature | Branch | State | Developer | Reviewer | IDE Buddy | LDM Champ |
 | ------- | ------ | ----- | --------- | -------- | --------- | --------- |
 | [Ref Struct Interfaces](https://github.com/dotnet/csharplang/issues/7608) | [RefStructInterfaces](https://github.com/dotnet/roslyn/tree/features/RefStructInterfaces) | [In Progress](https://github.com/dotnet/roslyn/issues/72124) | [AlekseyTs](https://github.com/AlekseyTs) | [cston](https://github.com/cston), [jjonescz](https://github.com/jjonescz) |  |  [agocke](https://github.com/agocke), [jaredpar](https://github.com/jaredpar) |
-| [Params-collections](https://github.com/dotnet/csharplang/issues/7700) | [ParamsCollections](https://github.com/dotnet/roslyn/tree/features/ParamsCollections) | [In Progress](https://github.com/dotnet/roslyn/issues/71137) | [AlekseyTs](https://github.com/AlekseyTs) | [RikkiGibson](https://github.com/RikkiGibson), [333fred](https://github.com/333fred) |  |  [MadsTorgersen](https://github.com/MadsTorgersen), [AlekseyTs](https://github.com/AlekseyTs) |
 | [Semi-auto-properties](https://github.com/dotnet/csharplang/issues/140) | [semi-auto-props](https://github.com/dotnet/roslyn/tree/features/semi-auto-props) | [In Progress](https://github.com/dotnet/roslyn/issues/57012) | [Youssef1313](https://github.com/Youssef1313) | [333fred](https://github.com/333fred), [RikkiGibson](https://github.com/RikkiGibson) |  | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
 | [Params Span\<T> + Stackalloc any array type](https://github.com/dotnet/csharplang/issues/1757) | [params-span](https://github.com/dotnet/roslyn/tree/features/params-span) | [In Progress](https://github.com/dotnet/roslyn/issues/57049) | [cston](https://github.com/cston) | TBD |  | [jaredpar](https://github.com/jaredpar) |
 | [Default in deconstruction](https://github.com/dotnet/roslyn/pull/25562) | [decon-default](https://github.com/dotnet/roslyn/tree/features/decon-default) | [In Progress](https://github.com/dotnet/roslyn/issues/25559) | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) |  | [jcouv](https://github.com/jcouv) |
@@ -20,6 +19,7 @@ efforts behind them.
 | [Method group natural type improvements](https://github.com/dotnet/csharplang/blob/main/proposals/method-group-natural-type-improvements.md) | main | [Merged into 17.9p2](https://github.com/dotnet/roslyn/issues/69432) | [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs), [cston](https://github.com/cston) |  | [jcouv](https://github.com/jcouv) |
 | [`Lock` object](https://github.com/dotnet/csharplang/issues/7104) | [LockObject](https://github.com/dotnet/roslyn/tree/features/LockObject) | [Merged into 17.10p2](https://github.com/dotnet/roslyn/issues/71888) | [jjonescz](https://github.com/jjonescz) | [cston](https://github.com/cston), [RikkiGibson](https://github.com/RikkiGibson) | | [stephentoub](https://github.com/stephentoub) |
 | Implicit indexer access in object initializers | main | [Merged into 17.9p3](https://github.com/dotnet/roslyn/pull/70649) | [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs), [cston](https://github.com/cston) |  |  |
+| [Params-collections](https://github.com/dotnet/csharplang/issues/7700) | main | [Merged to 17.10p3](https://github.com/dotnet/roslyn/issues/71137) | [AlekseyTs](https://github.com/AlekseyTs) | [RikkiGibson](https://github.com/RikkiGibson), [333fred](https://github.com/333fred) |  |  [MadsTorgersen](https://github.com/MadsTorgersen), [AlekseyTs](https://github.com/AlekseyTs) |
 
 # C# 12.0
 

From 42a391b18248208a8f222a5fd9ff69224ffa633e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 17:04:46 -0700
Subject: [PATCH 040/170] in proc

---
 .../Host/RemoteWorkspace_SolutionCaching.cs   | 70 +++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
index 55139168584a5..3a6f6ae3d87f7 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
@@ -8,6 +8,76 @@
 
 namespace Microsoft.CodeAnalysis.Remote
 {
+    /// <summary>
+    /// Not threadsafe.  Only use while under a lock.
+    /// </summary>
+    internal sealed class RemoteSolutionCache
+    {
+        private sealed class SolutionCacheNode
+        {
+            public readonly Checksum Checksum;
+            public Solution? Solution;
+
+            public SolutionCacheNode(Checksum checksum)
+            {
+                Checksum = checksum;
+            }
+        }
+
+        /// <summary>
+        /// The max number of solution instances we'll hold onto at a time.
+        /// </summary>
+        private const int MaxCapacity = 4;
+
+        /// <summary>
+        /// The total history kept.  Used to record telemetry about how useful it would be to increase the max capacity.
+        /// </summary>
+        private const int TotalHistory = 16;
+
+        private readonly LinkedList<SolutionCacheNode> _cacheNodes = new();
+
+        public void Add(Checksum checksum, Solution solution)
+        {
+            var index = 0;
+            for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
+            {
+                if (current.Value.Checksum == checksum)
+                {
+                    // Found the item.  Take it, move it to the front, and ensure it's pointing at this solution.
+                    _cacheNodes.Remove(current);
+                    _cacheNodes.AddFirst(current);
+
+                    // Keep track if we would have found this if the cache was larger
+                    var cacheMiss = current.Value.Solution == null;
+                    current.Value.Solution = solution;
+
+                    DropExcessItems();
+                    return;
+                }
+            }
+
+            // Didn't find the item at all.  Just add to the front.
+            _cacheNodes.AddFirst(new SolutionCacheNode(checksum) { Solution = solution });
+            DropExcessItems();
+
+            // Ensure we're not storing too much history.
+            if (_cacheNodes.Count > TotalHistory)
+                _cacheNodes.RemoveLast();
+        }
+
+        private void DropExcessItems()
+        {
+            var index = 0;
+            for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
+            {
+                // Don't have to keep going once we stop having solutions.
+                if (current.Value.Solution is null)
+                    return;
+
+                if (index == MaxCapacity)
+            }
+        }
+
     internal sealed partial class RemoteWorkspace
     {
         /// <summary>

From 4f55d5400114c6254468e5659c2b7a6412debab0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 17:30:17 -0700
Subject: [PATCH 041/170] in proc

---
 .../Host/RemoteWorkspace_SolutionCaching.cs   | 100 +++++++++++++-----
 1 file changed, 73 insertions(+), 27 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
index 3a6f6ae3d87f7..d74c3271067f8 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.CodeAnalysis.Internal.Log;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Remote
@@ -13,6 +14,40 @@ namespace Microsoft.CodeAnalysis.Remote
     /// </summary>
     internal sealed class RemoteSolutionCache
     {
+        /// <summary>
+        /// The max number of solution instances we'll hold onto at a time.
+        /// </summary>
+        private const int MaxCapacity = 4;
+
+        /// <summary>
+        /// The total history kept.  Used to record telemetry about how useful it would be to increase the max capacity.
+        /// </summary>
+        private const int TotalHistory = 16;
+
+        /// <summary>
+        /// Keep track of when we find a checksum in the history, but we've dropped the solution for it.  This will help
+        /// us determine what benefit we would get from expanding this cache.
+        /// </summary>
+        private readonly HistogramLogAggregator<int>.HistogramCounter _cacheMissAggregator =
+            new(bucketSize: 1, maxBucketValue: int.MaxValue, bucketCount: TotalHistory + 1);
+
+        /// <summary>
+        /// The number of times we successfully found a solution.
+        /// </summary>
+        private int _cacheHits;
+
+        /// <summary>
+        /// The number of times we failed to find a solution, but could have found it if we cached more items (up to
+        /// TotalHistory).  When this happens, we also store in <see cref="_cacheMissAggregator"/> which bucket it was
+        /// found in to help us decide what a good cache value is.
+        /// </summary>
+        private int _cacheMissesInHistory;
+
+        /// <summary>
+        /// The number of times we failed to find a solution, and would not have found it even if we didn't cache more items.
+        /// </summary>
+        private int _cacheMissesNotInHistory;
+
         private sealed class SolutionCacheNode
         {
             public readonly Checksum Checksum;
@@ -24,19 +59,9 @@ public SolutionCacheNode(Checksum checksum)
             }
         }
 
-        /// <summary>
-        /// The max number of solution instances we'll hold onto at a time.
-        /// </summary>
-        private const int MaxCapacity = 4;
-
-        /// <summary>
-        /// The total history kept.  Used to record telemetry about how useful it would be to increase the max capacity.
-        /// </summary>
-        private const int TotalHistory = 16;
-
         private readonly LinkedList<SolutionCacheNode> _cacheNodes = new();
 
-        public void Add(Checksum checksum, Solution solution)
+        private void FindAndMoveNodeToFront(Checksum checksum)
         {
             var index = 0;
             for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
@@ -48,35 +73,56 @@ public void Add(Checksum checksum, Solution solution)
                     _cacheNodes.AddFirst(current);
 
                     // Keep track if we would have found this if the cache was larger
-                    var cacheMiss = current.Value.Solution == null;
-                    current.Value.Solution = solution;
-
-                    DropExcessItems();
+                    if (current.Value.Solution == null)
+                    {
+                        _cacheHits++;
+                    }
+                    else
+                    {
+                        _cacheMissesInHistory++;
+                        _cacheMissAggregator.IncreaseCount(index);
+                    }
                     return;
                 }
             }
 
             // Didn't find the item at all.  Just add to the front.
-            _cacheNodes.AddFirst(new SolutionCacheNode(checksum) { Solution = solution });
-            DropExcessItems();
-
-            // Ensure we're not storing too much history.
-            if (_cacheNodes.Count > TotalHistory)
-                _cacheNodes.RemoveLast();
+            //
+            // Note: we don't record 
+            _cacheNodes.AddFirst(new SolutionCacheNode(checksum));
+            _cacheMissesNotInHistory++;
+            return;
         }
 
-        private void DropExcessItems()
+        public void Add(Checksum checksum, Solution solution)
         {
+            Contract.ThrowIfTrue(_cacheNodes.Count > TotalHistory);
+
+            FindAndMoveNodeToFront(checksum);
+
+            Contract.ThrowIfTrue(_cacheNodes.Count > TotalHistory + 1);
+            Contract.ThrowIfNull(_cacheNodes.First);
+            Contract.ThrowIfTrue(_cacheNodes.First.Value.Checksum != checksum);
+
+            // Ensure we're holding onto the solution.
+            _cacheNodes.First.Value.Solution = solution;
+
+            // Now, if our history is too long, remove the last item.
+            if (_cacheNodes.Count == TotalHistory + 1)
+                _cacheNodes.RemoveLast();
+
+            // Finally, ensure that only the first `MaxCapacity` are pointing at solutions and the rest are not.
             var index = 0;
             for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
             {
-                // Don't have to keep going once we stop having solutions.
-                if (current.Value.Solution is null)
-                    return;
-
-                if (index == MaxCapacity)
+                if (index > MaxCapacity)
+                {
+                    current.Value.Solution = null;
+                    break;
+                }
             }
         }
+    }
 
     internal sealed partial class RemoteWorkspace
     {

From 3538ab62a98523e5f0ca3d2cb901897bb6a677f5 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 17:32:40 -0700
Subject: [PATCH 042/170] in proc

---
 src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs  | 2 +-
 .../ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
index b68de4597e65d..89ba049c3e282 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
@@ -164,7 +164,7 @@ await RunWithSolutionAsync(
                     if (updatePrimaryBranch)
                         _lastRequestedPrimaryBranchSolution = (solutionChecksum, solution);
                     else
-                        _lastRequestedAnyBranchSolution = (solutionChecksum, solution);
+                        _lastRequestedAnyBranchSolutions.Add(solutionChecksum, solution);
                 }
 
                 // Now, pass it to the callback to do the work.  Any other callers into us will be able to benefit from
diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
index d74c3271067f8..da3693456df6f 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
@@ -137,7 +137,7 @@ internal sealed partial class RemoteWorkspace
         /// The last solution requested by a service.  Cached as it's very common to have a flurry of requests for the
         /// same checksum that don't run concurrently.  Only read/write while holding <see cref="_gate"/>.
         /// </summary>
-        private (Checksum checksum, Solution solution) _lastRequestedAnyBranchSolution;
+        private readonly RemoteSolutionCache _lastRequestedAnyBranchSolutions = new();
 
         /// <summary>
         /// Mapping from solution-checksum to the solution computed for it.  This is used so that we can hold a solution
@@ -196,9 +196,9 @@ InFlightSolution GetOrCreateSolutionAndAddInFlightCount_NoLock()
 
                 // See if we're being asked for a checksum we already have cached a solution for.  Safe to read directly
                 // as we're holding _gate.
-                var cachedSolution =
-                    _lastRequestedPrimaryBranchSolution.checksum == solutionChecksum ? _lastRequestedPrimaryBranchSolution.solution :
-                    _lastRequestedAnyBranchSolution.checksum == solutionChecksum ? _lastRequestedAnyBranchSolution.solution : null;
+                var cachedSolution = _lastRequestedPrimaryBranchSolution.checksum == solutionChecksum
+                    ? _lastRequestedPrimaryBranchSolution.solution
+                    : _lastRequestedAnyBranchSolutions.Find(solutionChecksum);
 
                 // We're the first call that is asking about this checksum.  Kick off async computation to compute it
                 // (or use an existing cached value we already have).  Start with an in-flight-count of 1 to represent

From afd29eb622cd7373d2dbd3875c57f98efcd60027 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 17:47:19 -0700
Subject: [PATCH 043/170] in proc

---
 .../Remote/ServiceHub/Host/RemoteWorkspace.cs |  2 +-
 .../Host/RemoteWorkspace_SolutionCaching.cs   | 46 ++++++++++++-------
 2 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
index 89ba049c3e282..0471dfcde019e 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs
@@ -48,7 +48,7 @@ public AssetProvider CreateAssetProvider(Checksum solutionChecksum, SolutionAsse
         /// <summary>
         /// Syncs over the solution corresponding to <paramref name="solutionChecksum"/> and sets it as the current
         /// solution for <see langword="this"/> workspace.  This will also end up updating <see
-        /// cref="_lastRequestedAnyBranchSolution"/> and <see cref="_lastRequestedPrimaryBranchSolution"/>, allowing
+        /// cref="_lastRequestedAnyBranchSolutions"/> and <see cref="_lastRequestedPrimaryBranchSolution"/>, allowing
         /// them to be pre-populated for feature requests that come in soon after this call completes.
         /// </summary>
         public async Task UpdatePrimaryBranchSolutionAsync(
diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
index da3693456df6f..51c840984e8db 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
@@ -28,7 +28,7 @@ internal sealed class RemoteSolutionCache
         /// Keep track of when we find a checksum in the history, but we've dropped the solution for it.  This will help
         /// us determine what benefit we would get from expanding this cache.
         /// </summary>
-        private readonly HistogramLogAggregator<int>.HistogramCounter _cacheMissAggregator =
+        private readonly HistogramLogAggregator<int>.HistogramCounter _cacheMissCounter =
             new(bucketSize: 1, maxBucketValue: int.MaxValue, bucketCount: TotalHistory + 1);
 
         /// <summary>
@@ -71,27 +71,12 @@ private void FindAndMoveNodeToFront(Checksum checksum)
                     // Found the item.  Take it, move it to the front, and ensure it's pointing at this solution.
                     _cacheNodes.Remove(current);
                     _cacheNodes.AddFirst(current);
-
-                    // Keep track if we would have found this if the cache was larger
-                    if (current.Value.Solution == null)
-                    {
-                        _cacheHits++;
-                    }
-                    else
-                    {
-                        _cacheMissesInHistory++;
-                        _cacheMissAggregator.IncreaseCount(index);
-                    }
                     return;
                 }
             }
 
             // Didn't find the item at all.  Just add to the front.
-            //
-            // Note: we don't record 
             _cacheNodes.AddFirst(new SolutionCacheNode(checksum));
-            _cacheMissesNotInHistory++;
-            return;
         }
 
         public void Add(Checksum checksum, Solution solution)
@@ -122,6 +107,35 @@ public void Add(Checksum checksum, Solution solution)
                 }
             }
         }
+
+        public Solution? Find(Checksum checksum)
+        {
+            var index = 0;
+            for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
+            {
+                if (current.Value.Checksum == checksum)
+                {
+                    // Found it!
+                    if (current.Value.Solution is null)
+                    {
+                        // Track that we would have been able to return this if our history was longer.
+                        _cacheMissesInHistory++;
+                        _cacheMissCounter.IncreaseCount(index);
+                    }
+                    else
+                    {
+                        // Success!
+                        _cacheHits++;
+                    }
+
+                    return current.Value.Solution;
+                }
+            }
+
+            // Couldn't find it at all, even in the history.
+            _cacheMissesNotInHistory++;
+            return null;
+        }
     }
 
     internal sealed partial class RemoteWorkspace

From a7399930c8443625d40163d2e1766935eb461937 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 18:02:05 -0700
Subject: [PATCH 044/170] in progress

---
 .../Host/RemoteWorkspace_SolutionCaching.cs     | 17 ++++++++++++++---
 .../Compiler/Core/Log/FunctionId.cs             |  2 ++
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
index 51c840984e8db..fa8fc7bd2fadf 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
@@ -38,7 +38,7 @@ internal sealed class RemoteSolutionCache
 
         /// <summary>
         /// The number of times we failed to find a solution, but could have found it if we cached more items (up to
-        /// TotalHistory).  When this happens, we also store in <see cref="_cacheMissAggregator"/> which bucket it was
+        /// TotalHistory).  When this happens, we also store in <see cref="_cacheMissCounter"/> which bucket it was
         /// found in to help us decide what a good cache value is.
         /// </summary>
         private int _cacheMissesInHistory;
@@ -136,6 +136,17 @@ public void Add(Checksum checksum, Solution solution)
             _cacheMissesNotInHistory++;
             return null;
         }
+
+        public void ReportTelemetry()
+        {
+            Logger.Log(FunctionId.RemoteWorkspace_SolutionCachingStatistics, KeyValueLogMessage.Create(m =>
+            {
+                m.Add(nameof(_cacheHits), _cacheHits);
+                m.Add(nameof(_cacheMissesInHistory), _cacheMissesInHistory);
+                m.Add(nameof(_cacheMissesNotInHistory), _cacheMissesNotInHistory);
+                _cacheMissCounter.WriteTelemetryPropertiesTo(m, prefix: nameof(_cacheMissCounter));
+            }));
+        }
     }
 
     internal sealed partial class RemoteWorkspace
@@ -148,8 +159,8 @@ internal sealed partial class RemoteWorkspace
         private (Checksum checksum, Solution solution) _lastRequestedPrimaryBranchSolution;
 
         /// <summary>
-        /// The last solution requested by a service.  Cached as it's very common to have a flurry of requests for the
-        /// same checksum that don't run concurrently.  Only read/write while holding <see cref="_gate"/>.
+        /// Cache of last N solutions requested by a service.  Cached as it's very common to have a flurry of requests
+        /// for the same few checksum that don't run concurrently.  Only read/write while holding <see cref="_gate"/>.
         /// </summary>
         private readonly RemoteSolutionCache _lastRequestedAnyBranchSolutions = new();
 
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
index 856fee04a36e8..10f517d82a91f 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Log/FunctionId.cs
@@ -619,4 +619,6 @@ internal enum FunctionId
     SuggestedAction_Preview_Summary = 745,
 
     LSP_DocumentIdCacheMiss = 746,
+
+    RemoteWorkspace_SolutionCachingStatistics = 750,
 }

From 762c01a77553e834136873bf9080d641444e816f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 18:09:14 -0700
Subject: [PATCH 045/170] Make generic

---
 .../ServiceHub/Host/RemoteSolutionCache.cs    | 152 ++++++++++++++++++
 .../Host/RemoteWorkspace_SolutionCaching.cs   | 141 +---------------
 2 files changed, 153 insertions(+), 140 deletions(-)
 create mode 100644 src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
new file mode 100644
index 0000000000000..b6031f8617938
--- /dev/null
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
@@ -0,0 +1,152 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.Internal.Log;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Remote;
+
+/// <summary>
+/// Not threadsafe.  Only use while under a lock.
+/// </summary>
+internal sealed class RemoteSolutionCache<TChecksum, TSolution>
+    where TChecksum : struct
+    where TSolution : class
+{
+    /// <summary>
+    /// The max number of solution instances we'll hold onto at a time.
+    /// </summary>
+    private readonly int _maxCapacity;
+
+    /// <summary>
+    /// The total history kept.  Used to record telemetry about how useful it would be to increase the max capacity.
+    /// </summary>
+    private readonly int _totalHistory;
+
+    /// <summary>
+    /// Keep track of when we find a checksum in the history, but we've dropped the solution for it.  This will help
+    /// us determine what benefit we would get from expanding this cache.
+    /// </summary>
+    private readonly HistogramLogAggregator<int>.HistogramCounter _cacheMissCounter;
+
+    /// <summary>
+    /// The number of times we successfully found a solution.
+    /// </summary>
+    private int _cacheHits;
+
+    /// <summary>
+    /// The number of times we failed to find a solution, but could have found it if we cached more items (up to
+    /// TotalHistory).  When this happens, we also store in <see cref="_cacheMissCounter"/> which bucket it was
+    /// found in to help us decide what a good cache value is.
+    /// </summary>
+    private int _cacheMissesInHistory;
+
+    /// <summary>
+    /// The number of times we failed to find a solution, and would not have found it even if we didn't cache more items.
+    /// </summary>
+    private int _cacheMissesNotInHistory;
+
+    private readonly LinkedList<CacheNode> _cacheNodes = new();
+
+    public RemoteSolutionCache(int maxCapacity = 4, int totalHistory = 16)
+    {
+        _maxCapacity = maxCapacity;
+        _totalHistory = totalHistory;
+        _cacheMissCounter = new(bucketSize: 1, maxBucketValue: int.MaxValue, bucketCount: _totalHistory + 1);
+    }
+
+    private void FindAndMoveNodeToFront(TChecksum checksum)
+    {
+        var index = 0;
+        for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
+        {
+            if (current.Value.Checksum.Equals(checksum))
+            {
+                // Found the item.  Take it, move it to the front, and ensure it's pointing at this solution.
+                _cacheNodes.Remove(current);
+                _cacheNodes.AddFirst(current);
+                return;
+            }
+        }
+
+        // Didn't find the item at all.  Just add to the front.
+        _cacheNodes.AddFirst(new CacheNode(checksum));
+    }
+
+    public void Add(TChecksum checksum, TSolution solution)
+    {
+        Contract.ThrowIfTrue(_cacheNodes.Count > _totalHistory);
+
+        FindAndMoveNodeToFront(checksum);
+
+        Contract.ThrowIfTrue(_cacheNodes.Count > _totalHistory + 1);
+        Contract.ThrowIfNull(_cacheNodes.First);
+        Contract.ThrowIfFalse(_cacheNodes.First.Value.Checksum.Equals(checksum));
+
+        // Ensure we're holding onto the solution.
+        _cacheNodes.First.Value.Solution = solution;
+
+        // Now, if our history is too long, remove the last item.
+        if (_cacheNodes.Count == _totalHistory + 1)
+            _cacheNodes.RemoveLast();
+
+        // Finally, ensure that only the first `MaxCapacity` are pointing at solutions and the rest are not.
+        var index = 0;
+        for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
+        {
+            if (index > _maxCapacity)
+            {
+                current.Value.Solution = null;
+                break;
+            }
+        }
+    }
+
+    public TSolution? Find(Checksum checksum)
+    {
+        var index = 0;
+        for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
+        {
+            if (current.Value.Checksum.Equals(checksum))
+            {
+                // Found it!
+                if (current.Value.Solution is null)
+                {
+                    // Track that we would have been able to return this if our history was longer.
+                    _cacheMissesInHistory++;
+                    _cacheMissCounter.IncreaseCount(index);
+                }
+                else
+                {
+                    // Success!
+                    _cacheHits++;
+                }
+
+                return current.Value.Solution;
+            }
+        }
+
+        // Couldn't find it at all, even in the history.
+        _cacheMissesNotInHistory++;
+        return null;
+    }
+
+    public void ReportTelemetry()
+    {
+        Logger.Log(FunctionId.RemoteWorkspace_SolutionCachingStatistics, KeyValueLogMessage.Create(m =>
+        {
+            m.Add(nameof(_cacheHits), _cacheHits);
+            m.Add(nameof(_cacheMissesInHistory), _cacheMissesInHistory);
+            m.Add(nameof(_cacheMissesNotInHistory), _cacheMissesNotInHistory);
+            _cacheMissCounter.WriteTelemetryPropertiesTo(m, prefix: nameof(_cacheMissCounter));
+        }));
+    }
+
+    private sealed class CacheNode(TChecksum checksum)
+    {
+        public readonly TChecksum Checksum = checksum;
+        public TSolution? Solution;
+    }
+}
diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
index fa8fc7bd2fadf..d6c82aee29f98 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace_SolutionCaching.cs
@@ -9,145 +9,6 @@
 
 namespace Microsoft.CodeAnalysis.Remote
 {
-    /// <summary>
-    /// Not threadsafe.  Only use while under a lock.
-    /// </summary>
-    internal sealed class RemoteSolutionCache
-    {
-        /// <summary>
-        /// The max number of solution instances we'll hold onto at a time.
-        /// </summary>
-        private const int MaxCapacity = 4;
-
-        /// <summary>
-        /// The total history kept.  Used to record telemetry about how useful it would be to increase the max capacity.
-        /// </summary>
-        private const int TotalHistory = 16;
-
-        /// <summary>
-        /// Keep track of when we find a checksum in the history, but we've dropped the solution for it.  This will help
-        /// us determine what benefit we would get from expanding this cache.
-        /// </summary>
-        private readonly HistogramLogAggregator<int>.HistogramCounter _cacheMissCounter =
-            new(bucketSize: 1, maxBucketValue: int.MaxValue, bucketCount: TotalHistory + 1);
-
-        /// <summary>
-        /// The number of times we successfully found a solution.
-        /// </summary>
-        private int _cacheHits;
-
-        /// <summary>
-        /// The number of times we failed to find a solution, but could have found it if we cached more items (up to
-        /// TotalHistory).  When this happens, we also store in <see cref="_cacheMissCounter"/> which bucket it was
-        /// found in to help us decide what a good cache value is.
-        /// </summary>
-        private int _cacheMissesInHistory;
-
-        /// <summary>
-        /// The number of times we failed to find a solution, and would not have found it even if we didn't cache more items.
-        /// </summary>
-        private int _cacheMissesNotInHistory;
-
-        private sealed class SolutionCacheNode
-        {
-            public readonly Checksum Checksum;
-            public Solution? Solution;
-
-            public SolutionCacheNode(Checksum checksum)
-            {
-                Checksum = checksum;
-            }
-        }
-
-        private readonly LinkedList<SolutionCacheNode> _cacheNodes = new();
-
-        private void FindAndMoveNodeToFront(Checksum checksum)
-        {
-            var index = 0;
-            for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
-            {
-                if (current.Value.Checksum == checksum)
-                {
-                    // Found the item.  Take it, move it to the front, and ensure it's pointing at this solution.
-                    _cacheNodes.Remove(current);
-                    _cacheNodes.AddFirst(current);
-                    return;
-                }
-            }
-
-            // Didn't find the item at all.  Just add to the front.
-            _cacheNodes.AddFirst(new SolutionCacheNode(checksum));
-        }
-
-        public void Add(Checksum checksum, Solution solution)
-        {
-            Contract.ThrowIfTrue(_cacheNodes.Count > TotalHistory);
-
-            FindAndMoveNodeToFront(checksum);
-
-            Contract.ThrowIfTrue(_cacheNodes.Count > TotalHistory + 1);
-            Contract.ThrowIfNull(_cacheNodes.First);
-            Contract.ThrowIfTrue(_cacheNodes.First.Value.Checksum != checksum);
-
-            // Ensure we're holding onto the solution.
-            _cacheNodes.First.Value.Solution = solution;
-
-            // Now, if our history is too long, remove the last item.
-            if (_cacheNodes.Count == TotalHistory + 1)
-                _cacheNodes.RemoveLast();
-
-            // Finally, ensure that only the first `MaxCapacity` are pointing at solutions and the rest are not.
-            var index = 0;
-            for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
-            {
-                if (index > MaxCapacity)
-                {
-                    current.Value.Solution = null;
-                    break;
-                }
-            }
-        }
-
-        public Solution? Find(Checksum checksum)
-        {
-            var index = 0;
-            for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
-            {
-                if (current.Value.Checksum == checksum)
-                {
-                    // Found it!
-                    if (current.Value.Solution is null)
-                    {
-                        // Track that we would have been able to return this if our history was longer.
-                        _cacheMissesInHistory++;
-                        _cacheMissCounter.IncreaseCount(index);
-                    }
-                    else
-                    {
-                        // Success!
-                        _cacheHits++;
-                    }
-
-                    return current.Value.Solution;
-                }
-            }
-
-            // Couldn't find it at all, even in the history.
-            _cacheMissesNotInHistory++;
-            return null;
-        }
-
-        public void ReportTelemetry()
-        {
-            Logger.Log(FunctionId.RemoteWorkspace_SolutionCachingStatistics, KeyValueLogMessage.Create(m =>
-            {
-                m.Add(nameof(_cacheHits), _cacheHits);
-                m.Add(nameof(_cacheMissesInHistory), _cacheMissesInHistory);
-                m.Add(nameof(_cacheMissesNotInHistory), _cacheMissesNotInHistory);
-                _cacheMissCounter.WriteTelemetryPropertiesTo(m, prefix: nameof(_cacheMissCounter));
-            }));
-        }
-    }
 
     internal sealed partial class RemoteWorkspace
     {
@@ -162,7 +23,7 @@ internal sealed partial class RemoteWorkspace
         /// Cache of last N solutions requested by a service.  Cached as it's very common to have a flurry of requests
         /// for the same few checksum that don't run concurrently.  Only read/write while holding <see cref="_gate"/>.
         /// </summary>
-        private readonly RemoteSolutionCache _lastRequestedAnyBranchSolutions = new();
+        private readonly RemoteSolutionCache<Checksum, Solution> _lastRequestedAnyBranchSolutions = new();
 
         /// <summary>
         /// Mapping from solution-checksum to the solution computed for it.  This is used so that we can hold a solution

From d45336a1538b773a287b869f4a1026c8f1e8b115 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 18:23:16 -0700
Subject: [PATCH 046/170] Add tests

---
 .../Remote/RemoteSolutionCacheTests.cs        | 137 ++++++++++++++++++
 .../ServiceHub/Host/RemoteSolutionCache.cs    |   5 +-
 2 files changed, 140 insertions(+), 2 deletions(-)
 create mode 100644 src/VisualStudio/Core/Test.Next/Remote/RemoteSolutionCacheTests.cs

diff --git a/src/VisualStudio/Core/Test.Next/Remote/RemoteSolutionCacheTests.cs b/src/VisualStudio/Core/Test.Next/Remote/RemoteSolutionCacheTests.cs
new file mode 100644
index 0000000000000..a4ea86a254f6f
--- /dev/null
+++ b/src/VisualStudio/Core/Test.Next/Remote/RemoteSolutionCacheTests.cs
@@ -0,0 +1,137 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis.Remote;
+using Xunit;
+
+namespace Roslyn.VisualStudio.Next.UnitTests.Remote;
+
+public class RemoteSolutionCacheTests
+{
+    [Fact]
+    public void TestAddAndFind1()
+    {
+        var cache = new RemoteSolutionCache<int, string>(maxCapacity: 4);
+        cache.Add(1, "1");
+        Assert.Equal("1", cache.Find(1));
+        Assert.Null(cache.Find(2));
+    }
+
+    [Fact]
+    public void TestAddAndFindOverwrite1()
+    {
+        var cache = new RemoteSolutionCache<int, string>(maxCapacity: 4);
+        cache.Add(1, "1");
+        cache.Add(1, "2");
+        Assert.Equal("2", cache.Find(1));
+        Assert.Null(cache.Find(2));
+    }
+
+    [Fact]
+    public void TestAddAndFindOverwrite2()
+    {
+        var cache = new RemoteSolutionCache<int, string>(maxCapacity: 4);
+        cache.Add(1, "1");
+        cache.Add(2, "2");
+        cache.Add(1, "3");
+        Assert.Equal("3", cache.Find(1));
+        Assert.Equal("2", cache.Find(2));
+        Assert.Null(cache.Find(3));
+    }
+
+    [Fact]
+    public void TestAddAndFindFour()
+    {
+        var cache = new RemoteSolutionCache<int, string>(maxCapacity: 4);
+        cache.Add(1, "1");
+        cache.Add(2, "2");
+        cache.Add(3, "3");
+        cache.Add(4, "4");
+        Assert.Equal("1", cache.Find(1));
+        Assert.Equal("2", cache.Find(2));
+        Assert.Equal("3", cache.Find(3));
+        Assert.Equal("4", cache.Find(4));
+        Assert.Null(cache.Find(5));
+    }
+
+    [Fact]
+    public void TestAddAndFindFive_A()
+    {
+        var cache = new RemoteSolutionCache<int, string>(maxCapacity: 4);
+        cache.Add(1, "1");
+        cache.Add(2, "2");
+        cache.Add(3, "3");
+        cache.Add(4, "4");
+        cache.Add(5, "5");
+        Assert.Null(cache.Find(1));
+        Assert.Equal("2", cache.Find(2));
+        Assert.Equal("3", cache.Find(3));
+        Assert.Equal("4", cache.Find(4));
+        Assert.Equal("5", cache.Find(5));
+        Assert.Null(cache.Find(6));
+    }
+
+    [Fact]
+    public void TestAddAndFindFive_B()
+    {
+        var cache = new RemoteSolutionCache<int, string>(maxCapacity: 4);
+        cache.Add(1, "1");
+        cache.Add(2, "2");
+        cache.Add(3, "3");
+        cache.Add(4, "4");
+        cache.Add(1, "1"); // re-add.  should ensure that this doesn't fall out of the cache.
+        cache.Add(5, "5");
+        Assert.Equal("1", cache.Find(1));
+        Assert.Null(cache.Find(2));
+        Assert.Equal("3", cache.Find(3));
+        Assert.Equal("4", cache.Find(4));
+        Assert.Equal("5", cache.Find(5));
+        Assert.Null(cache.Find(6));
+    }
+
+    [Fact]
+    public void TestLargeHistory_A()
+    {
+        var cache = new RemoteSolutionCache<int, string>(maxCapacity: 4, totalHistory: 16);
+
+        for (var i = 0; i < 20; i++)
+            cache.Add(i, $"{i}");
+
+        for (var i = 0; i < 20; i++)
+        {
+            if (i < 16)
+            {
+                Assert.Null(cache.Find(i));
+            }
+            else
+            {
+                Assert.Equal($"{i}", cache.Find(i));
+            }
+        }
+    }
+
+    [Fact]
+    public void TestLargeHistory_B()
+    {
+        var cache = new RemoteSolutionCache<int, string>(maxCapacity: 4, totalHistory: 16);
+
+        for (var i = 0; i < 20; i++)
+            cache.Add(i, $"{i}");
+
+        for (var i = 20 - 1; i >= 0; i--)
+            cache.Add(i, $"{i}");
+
+        for (var i = 0; i < 20; i++)
+        {
+            if (i >= 4)
+            {
+                Assert.Null(cache.Find(i));
+            }
+            else
+            {
+                Assert.Equal($"{i}", cache.Find(i));
+            }
+        }
+    }
+}
diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
index b6031f8617938..cf76645d9d5cd 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
@@ -96,7 +96,7 @@ public void Add(TChecksum checksum, TSolution solution)
         var index = 0;
         for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
         {
-            if (index > _maxCapacity)
+            if (index >= _maxCapacity)
             {
                 current.Value.Solution = null;
                 break;
@@ -104,8 +104,9 @@ public void Add(TChecksum checksum, TSolution solution)
         }
     }
 
-    public TSolution? Find(Checksum checksum)
+    public TSolution? Find(TChecksum checksum)
     {
+        // Note: we intentionally do not move an item when we find it.  That's because 
         var index = 0;
         for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
         {

From b8bd8786bee6f9bc865f196210a12b4fe3645004 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 18:24:03 -0700
Subject: [PATCH 047/170] Comment

---
 src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
index cf76645d9d5cd..c8817b4c14d9b 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
@@ -106,7 +106,8 @@ public void Add(TChecksum checksum, TSolution solution)
 
     public TSolution? Find(TChecksum checksum)
     {
-        // Note: we intentionally do not move an item when we find it.  That's because 
+        // Note: we intentionally do not move an item when we find it.  That's because our caller will always call 'Add'
+        // with the found solution afterwards.  This will ensure that that solution makes it to the front of the line.
         var index = 0;
         for (var current = _cacheNodes.First; current != null; current = current.Next, index++)
         {

From 405abde013064ac40815d721dc48e35ecb1450f0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 18:27:23 -0700
Subject: [PATCH 048/170] Docs

---
 .../Remote/ServiceHub/Host/RemoteSolutionCache.cs          | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
index c8817b4c14d9b..d997c6090bcbd 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
@@ -9,6 +9,8 @@
 namespace Microsoft.CodeAnalysis.Remote;
 
 /// <summary>
+/// LRU cache of checksum+solution pairs.  Used to keep track of the last few solutions the remote server knows about,
+/// helping to avoid unnecessary syncs/recreations of those solutions while many requests are coming into the server.
 /// Not threadsafe.  Only use while under a lock.
 /// </summary>
 internal sealed class RemoteSolutionCache<TChecksum, TSolution>
@@ -48,6 +50,11 @@ internal sealed class RemoteSolutionCache<TChecksum, TSolution>
     /// </summary>
     private int _cacheMissesNotInHistory;
 
+    /// <summary>
+    /// The list of checksum+solution pairs.  Note: only the first <see cref="_maxCapacity"/> items will actually point
+    /// at a non-null solution.  The ones after that will point at <see langword="null"/>.  We store both so that we can
+    /// collect useful telemetry on how much benefit we would get by having a larger history.
+    /// </summary>
     private readonly LinkedList<CacheNode> _cacheNodes = new();
 
     public RemoteSolutionCache(int maxCapacity = 4, int totalHistory = 16)

From f5038ee081aa6861f61c839880041e9c845441e3 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 18:29:09 -0700
Subject: [PATCH 049/170] Update
 src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs

---
 src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
index d997c6090bcbd..f52abbcab22f4 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
@@ -71,7 +71,7 @@ private void FindAndMoveNodeToFront(TChecksum checksum)
         {
             if (current.Value.Checksum.Equals(checksum))
             {
-                // Found the item.  Take it, move it to the front, and ensure it's pointing at this solution.
+                // Found the item.  Take it, move it to the front.
                 _cacheNodes.Remove(current);
                 _cacheNodes.AddFirst(current);
                 return;

From 77871ac34a567bc1e6d5e9a4a3c6d2abb601dd23 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 18:35:57 -0700
Subject: [PATCH 050/170] Store all indices

---
 .../ServiceHub/Host/RemoteSolutionCache.cs     | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
index d997c6090bcbd..f22aa81b4da73 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
@@ -28,20 +28,20 @@ internal sealed class RemoteSolutionCache<TChecksum, TSolution>
     private readonly int _totalHistory;
 
     /// <summary>
-    /// Keep track of when we find a checksum in the history, but we've dropped the solution for it.  This will help
-    /// us determine what benefit we would get from expanding this cache.
+    /// Keep track of what index we found find a checksum at in the history.  This will help us tell both if the cache
+    /// is too large, or if it's too small.
     /// </summary>
-    private readonly HistogramLogAggregator<int>.HistogramCounter _cacheMissCounter;
+    private readonly HistogramLogAggregator<int>.HistogramCounter _cacheHitIndexHistogram;
 
     /// <summary>
-    /// The number of times we successfully found a solution.
+    /// The number of times we successfully found a solution.  When this happens we'll increment <see
+    /// cref="_cacheHitIndexHistogram"/>.
     /// </summary>
     private int _cacheHits;
 
     /// <summary>
     /// The number of times we failed to find a solution, but could have found it if we cached more items (up to
-    /// TotalHistory).  When this happens, we also store in <see cref="_cacheMissCounter"/> which bucket it was
-    /// found in to help us decide what a good cache value is.
+    /// TotalHistory).  When this happens we'll increment <see cref="_cacheHitIndexHistogram"/>.
     /// </summary>
     private int _cacheMissesInHistory;
 
@@ -61,7 +61,7 @@ public RemoteSolutionCache(int maxCapacity = 4, int totalHistory = 16)
     {
         _maxCapacity = maxCapacity;
         _totalHistory = totalHistory;
-        _cacheMissCounter = new(bucketSize: 1, maxBucketValue: int.MaxValue, bucketCount: _totalHistory + 1);
+        _cacheHitIndexHistogram = new(bucketSize: 1, maxBucketValue: int.MaxValue, bucketCount: _totalHistory + 1);
     }
 
     private void FindAndMoveNodeToFront(TChecksum checksum)
@@ -125,7 +125,6 @@ public void Add(TChecksum checksum, TSolution solution)
                 {
                     // Track that we would have been able to return this if our history was longer.
                     _cacheMissesInHistory++;
-                    _cacheMissCounter.IncreaseCount(index);
                 }
                 else
                 {
@@ -133,6 +132,7 @@ public void Add(TChecksum checksum, TSolution solution)
                     _cacheHits++;
                 }
 
+                _cacheHitIndexHistogram.IncreaseCount(index);
                 return current.Value.Solution;
             }
         }
@@ -149,7 +149,7 @@ public void ReportTelemetry()
             m.Add(nameof(_cacheHits), _cacheHits);
             m.Add(nameof(_cacheMissesInHistory), _cacheMissesInHistory);
             m.Add(nameof(_cacheMissesNotInHistory), _cacheMissesNotInHistory);
-            _cacheMissCounter.WriteTelemetryPropertiesTo(m, prefix: nameof(_cacheMissCounter));
+            _cacheHitIndexHistogram.WriteTelemetryPropertiesTo(m, prefix: nameof(_cacheHitIndexHistogram));
         }));
     }
 

From 2c3db16df15938842bd498bf0948b4c0e97787ed Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 19:00:52 -0700
Subject: [PATCH 051/170] Simplify base case

---
 .../Remote/ServiceHub/Host/RemoteSolutionCache.cs     | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
index accc70bf5b6ca..75660559eabdc 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteSolutionCache.cs
@@ -71,9 +71,14 @@ private void FindAndMoveNodeToFront(TChecksum checksum)
         {
             if (current.Value.Checksum.Equals(checksum))
             {
-                // Found the item.  Take it, move it to the front.
-                _cacheNodes.Remove(current);
-                _cacheNodes.AddFirst(current);
+                // Found the item.  
+                if (index > 0)
+                {
+                    // If it's not already at the front, move it there.
+                    _cacheNodes.Remove(current);
+                    _cacheNodes.AddFirst(current);
+                }
+
                 return;
             }
         }

From 98cd7d72ae535ac6ffc00d1ad88fa723bc28d492 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 21:59:13 -0700
Subject: [PATCH 052/170] Enhance supported cases for 'remove redundant
 operators'

---
 .../RemoveRedundantEqualityTests.cs           | 30 ++++++---
 ...moveRedundantEqualityDiagnosticAnalyzer.cs | 60 +++++++++---------
 .../RedundantEqualityConstants.cs             |  1 +
 .../RemoveRedundantEqualityCodeFixProvider.cs | 61 +++++++++----------
 .../RemoveRedundantEqualityTests.vb           | 26 +++++---
 5 files changed, 97 insertions(+), 81 deletions(-)

diff --git a/src/Analyzers/CSharp/Tests/RemoveRedundantEquality/RemoveRedundantEqualityTests.cs b/src/Analyzers/CSharp/Tests/RemoveRedundantEquality/RemoveRedundantEqualityTests.cs
index a3f9d594dbf8c..5f432749c27ee 100644
--- a/src/Analyzers/CSharp/Tests/RemoveRedundantEquality/RemoveRedundantEqualityTests.cs
+++ b/src/Analyzers/CSharp/Tests/RemoveRedundantEquality/RemoveRedundantEqualityTests.cs
@@ -44,16 +44,23 @@ public bool M1(bool x)
         [Fact]
         public async Task TestSimpleCaseForEqualsFalse_NoDiagnostics()
         {
-            var code = """
+            await VerifyCS.VerifyCodeFixAsync("""
                 public class C
                 {
                     public bool M1(bool x)
                     {
-                        return x == false;
+                        return x [|==|] false;
                     }
                 }
-                """;
-            await VerifyCS.VerifyAnalyzerAsync(code);
+                """, """
+                public class C
+                {
+                    public bool M1(bool x)
+                    {
+                        return !x;
+                    }
+                }
+                """);
         }
 
         [Fact]
@@ -83,16 +90,23 @@ public bool M1(bool x)
         [Fact]
         public async Task TestSimpleCaseForNotEqualsTrue_NoDiagnostics()
         {
-            var code = """
+            await VerifyCS.VerifyCodeFixAsync("""
                 public class C
                 {
                     public bool M1(bool x)
                     {
-                        return x != true;
+                        return x [|!=|] true;
                     }
                 }
-                """;
-            await VerifyCS.VerifyAnalyzerAsync(code);
+                """, """
+                public class C
+                {
+                    public bool M1(bool x)
+                    {
+                        return !x;
+                    }
+                }
+                """);
         }
 
         [Fact]
diff --git a/src/Analyzers/Core/Analyzers/RemoveRedundantEquality/AbstractRemoveRedundantEqualityDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/RemoveRedundantEquality/AbstractRemoveRedundantEqualityDiagnosticAnalyzer.cs
index de3de1f9883b1..8be778a4b7e10 100644
--- a/src/Analyzers/Core/Analyzers/RemoveRedundantEquality/AbstractRemoveRedundantEqualityDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveRedundantEquality/AbstractRemoveRedundantEqualityDiagnosticAnalyzer.cs
@@ -10,20 +10,13 @@
 
 namespace Microsoft.CodeAnalysis.RemoveRedundantEquality;
 
-internal abstract class AbstractRemoveRedundantEqualityDiagnosticAnalyzer
-    : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+internal abstract class AbstractRemoveRedundantEqualityDiagnosticAnalyzer(ISyntaxFacts syntaxFacts)
+    : AbstractBuiltInCodeStyleDiagnosticAnalyzer(
+        IDEDiagnosticIds.RemoveRedundantEqualityDiagnosticId,
+        EnforceOnBuildValues.RemoveRedundantEquality,
+        option: null,
+        new LocalizableResourceString(nameof(AnalyzersResources.Remove_redundant_equality), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)))
 {
-    private readonly ISyntaxFacts _syntaxFacts;
-
-    protected AbstractRemoveRedundantEqualityDiagnosticAnalyzer(ISyntaxFacts syntaxFacts)
-        : base(IDEDiagnosticIds.RemoveRedundantEqualityDiagnosticId,
-               EnforceOnBuildValues.RemoveRedundantEquality,
-               option: null,
-               new LocalizableResourceString(nameof(AnalyzersResources.Remove_redundant_equality), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)))
-    {
-        _syntaxFacts = syntaxFacts;
-    }
-
     public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
         => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
@@ -35,19 +28,15 @@ private void AnalyzeBinaryOperator(OperationAnalysisContext context)
         if (ShouldSkipAnalysis(context, notification: null))
             return;
 
+        // We shouldn't report diagnostic on overloaded operator as the behavior can change.
         var operation = (IBinaryOperation)context.Operation;
         if (operation.OperatorMethod is not null)
-        {
-            // We shouldn't report diagnostic on overloaded operator as the behavior can change.
             return;
-        }
 
         if (operation.OperatorKind is not (BinaryOperatorKind.Equals or BinaryOperatorKind.NotEquals))
-        {
             return;
-        }
 
-        if (!_syntaxFacts.IsBinaryExpression(operation.Syntax))
+        if (!syntaxFacts.IsBinaryExpression(operation.Syntax))
         {
             return;
         }
@@ -56,9 +45,7 @@ private void AnalyzeBinaryOperator(OperationAnalysisContext context)
         var leftOperand = operation.LeftOperand;
 
         if (rightOperand.Type is null || leftOperand.Type is null)
-        {
             return;
-        }
 
         if (rightOperand.Type.SpecialType != SpecialType.System_Boolean ||
             leftOperand.Type.SpecialType != SpecialType.System_Boolean)
@@ -67,25 +54,31 @@ private void AnalyzeBinaryOperator(OperationAnalysisContext context)
         }
 
         var isOperatorEquals = operation.OperatorKind == BinaryOperatorKind.Equals;
-        _syntaxFacts.GetPartsOfBinaryExpression(operation.Syntax, out _, out var operatorToken, out _);
+        syntaxFacts.GetPartsOfBinaryExpression(operation.Syntax, out _, out var operatorToken, out _);
+
         var properties = ImmutableDictionary.CreateBuilder<string, string?>();
-        if (TryGetLiteralValue(rightOperand) == isOperatorEquals)
+        if (TryGetLiteralValue(rightOperand) is bool rightBool)
         {
             properties.Add(RedundantEqualityConstants.RedundantSide, RedundantEqualityConstants.Right);
+            if (rightBool != isOperatorEquals)
+                properties.Add(RedundantEqualityConstants.Negate, RedundantEqualityConstants.Negate);
         }
-        else if (TryGetLiteralValue(leftOperand) == isOperatorEquals)
+        else if (TryGetLiteralValue(leftOperand) is bool leftBool)
         {
             properties.Add(RedundantEqualityConstants.RedundantSide, RedundantEqualityConstants.Left);
+            if (leftBool != isOperatorEquals)
+                properties.Add(RedundantEqualityConstants.Negate, RedundantEqualityConstants.Negate);
         }
-
-        if (properties.Count == 1)
+        else
         {
-            context.ReportDiagnostic(Diagnostic.Create(Descriptor,
-                operatorToken.GetLocation(),
-                additionalLocations: [operation.Syntax.GetLocation()],
-                properties: properties.ToImmutable()));
+            return;
         }
 
+        context.ReportDiagnostic(Diagnostic.Create(Descriptor,
+            operatorToken.GetLocation(),
+            additionalLocations: [operation.Syntax.GetLocation()],
+            properties: properties.ToImmutable()));
+
         return;
 
         static bool? TryGetLiteralValue(IOperation operand)
@@ -93,8 +86,11 @@ private void AnalyzeBinaryOperator(OperationAnalysisContext context)
             // Make sure we only simplify literals to avoid changing
             // something like the following example:
             // const bool Activated = true; ... if (state == Activated)
-            if (operand.ConstantValue.HasValue && operand.Kind == OperationKind.Literal &&
-                operand.ConstantValue.Value is bool constValue)
+            if (operand is
+                {
+                    Kind: OperationKind.Literal,
+                    ConstantValue: { HasValue: true, Value: bool constValue }
+                })
             {
                 return constValue;
             }
diff --git a/src/Analyzers/Core/Analyzers/RemoveRedundantEquality/RedundantEqualityConstants.cs b/src/Analyzers/Core/Analyzers/RemoveRedundantEquality/RedundantEqualityConstants.cs
index 9303d7d6b89fc..50629058eb1f5 100644
--- a/src/Analyzers/Core/Analyzers/RemoveRedundantEquality/RedundantEqualityConstants.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveRedundantEquality/RedundantEqualityConstants.cs
@@ -9,4 +9,5 @@ internal static class RedundantEqualityConstants
     public const string RedundantSide = nameof(RedundantSide);
     public const string Left = nameof(Left);
     public const string Right = nameof(Right);
+    public const string Negate = nameof(Negate);
 }
diff --git a/src/Analyzers/Core/CodeFixes/RemoveRedundantEquality/RemoveRedundantEqualityCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/RemoveRedundantEquality/RemoveRedundantEqualityCodeFixProvider.cs
index b79642762a6bd..6c5c51a7bba7b 100644
--- a/src/Analyzers/Core/CodeFixes/RemoveRedundantEquality/RemoveRedundantEqualityCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/RemoveRedundantEquality/RemoveRedundantEqualityCodeFixProvider.cs
@@ -21,54 +21,49 @@ namespace Microsoft.CodeAnalysis.RemoveRedundantEquality;
 [ExportCodeFixProvider(LanguageNames.CSharp, LanguageNames.VisualBasic, Name = PredefinedCodeFixProviderNames.RemoveRedundantEquality), Shared]
 [method: ImportingConstructor]
 [method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
-internal sealed class RemoveRedundantEqualityCodeFixProvider() : SyntaxEditorBasedCodeFixProvider
+internal sealed class RemoveRedundantEqualityCodeFixProvider() : ForkingSyntaxEditorBasedCodeFixProvider<SyntaxNode>
 {
     public override ImmutableArray<string> FixableDiagnosticIds => [IDEDiagnosticIds.RemoveRedundantEqualityDiagnosticId];
 
-    public override Task RegisterCodeFixesAsync(CodeFixContext context)
-    {
-        foreach (var diagnostic in context.Diagnostics)
-        {
-            RegisterCodeFix(context, AnalyzersResources.Remove_redundant_equality, nameof(AnalyzersResources.Remove_redundant_equality), diagnostic);
-        }
+    protected override (string title, string equivalenceKey) GetTitleAndEquivalenceKey(CodeFixContext context)
+        => (AnalyzersResources.Remove_redundant_equality, nameof(AnalyzersResources.Remove_redundant_equality));
 
-        return Task.CompletedTask;
-    }
-
-    protected override async Task FixAllAsync(Document document, ImmutableArray<Diagnostic> diagnostics, SyntaxEditor editor, CodeActionOptionsProvider fallbackOptions, CancellationToken cancellationToken)
+    protected override async Task FixAsync(
+        Document document,
+        SyntaxEditor editor,
+        CodeActionOptionsProvider fallbackOptions,
+        SyntaxNode node,
+        ImmutableDictionary<string, string?> properties,
+        CancellationToken cancellationToken)
     {
         var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        var generator = editor.Generator;
+        var generatorInternal = document.GetRequiredLanguageService<SyntaxGeneratorInternal>();
+
         var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
         var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
-        foreach (var diagnostic in diagnostics)
+        editor.ReplaceNode(node, WithElasticTrailingTrivia(RewriteNode()));
+
+        return;
+
+        SyntaxNode RewriteNode()
         {
-            var node = root.FindNode(diagnostic.AdditionalLocations[0].SourceSpan, getInnermostNodeForTie: true);
+            // This should happen only in error cases.
+            if (!syntaxFacts.IsBinaryExpression(node))
+                return node;
 
-            editor.ReplaceNode(node, (n, _) =>
-            {
-                if (!syntaxFacts.IsBinaryExpression(n))
-                {
-                    // This should happen only in error cases.
-                    return n;
-                }
+            syntaxFacts.GetPartsOfBinaryExpression(node, out var left, out var right);
+            var rewritten =
+                properties[RedundantEqualityConstants.RedundantSide] == RedundantEqualityConstants.Right ? left :
+                properties[RedundantEqualityConstants.RedundantSide] == RedundantEqualityConstants.Left ? right : node;
 
-                syntaxFacts.GetPartsOfBinaryExpression(n, out var left, out var right);
-                if (diagnostic.Properties[RedundantEqualityConstants.RedundantSide] == RedundantEqualityConstants.Right)
-                {
-                    return WithElasticTrailingTrivia(left);
-                }
-                else if (diagnostic.Properties[RedundantEqualityConstants.RedundantSide] == RedundantEqualityConstants.Left)
-                {
-                    return WithElasticTrailingTrivia(right);
-                }
+            if (properties.ContainsKey(RedundantEqualityConstants.Negate))
+                rewritten = generator.Negate(generatorInternal, rewritten, semanticModel, cancellationToken);
 
-                return n;
-            });
+            return rewritten;
         }
 
-        return;
-
         static SyntaxNode WithElasticTrailingTrivia(SyntaxNode node)
         {
             return node.WithTrailingTrivia(node.GetTrailingTrivia().Select(SyntaxTriviaExtensions.AsElastic));
diff --git a/src/Analyzers/VisualBasic/Tests/RemoveRedundantEquality/RemoveRedundantEqualityTests.vb b/src/Analyzers/VisualBasic/Tests/RemoveRedundantEquality/RemoveRedundantEqualityTests.vb
index 9e47f84472cff..994931792e16a 100644
--- a/src/Analyzers/VisualBasic/Tests/RemoveRedundantEquality/RemoveRedundantEqualityTests.vb
+++ b/src/Analyzers/VisualBasic/Tests/RemoveRedundantEquality/RemoveRedundantEqualityTests.vb
@@ -29,14 +29,19 @@ End Module
 
         <Fact>
         Public Async Function TestSimpleCaseForEqualsFalse_NoDiagnostics() As Task
-            Dim code = "
+            Await VerifyVB.VerifyCodeFixAsync("
 Public Module Module1
     Public Function M1(x As Boolean) As Boolean
-        Return x = False
+        Return x [|=|] False
     End Function
 End Module
-"
-            Await VerifyVB.VerifyAnalyzerAsync(code)
+", "
+Public Module Module1
+    Public Function M1(x As Boolean) As Boolean
+        Return Not x
+    End Function
+End Module
+")
         End Function
 
         <Fact>
@@ -60,14 +65,19 @@ End Module
 
         <Fact>
         Public Async Function TestSimpleCaseForNotEqualsTrue_NoDiagnostics() As Task
-            Dim code = "
+            Await VerifyVB.VerifyCodeFixAsync("
 Public Module Module1
     Public Function M1(x As Boolean) As Boolean
-        Return x <> True
+        Return x [|<>|] True
     End Function
 End Module
-"
-            Await VerifyVB.VerifyAnalyzerAsync(code)
+", "
+Public Module Module1
+    Public Function M1(x As Boolean) As Boolean
+        Return Not x
+    End Function
+End Module
+")
         End Function
 
         <Fact>

From 326db66e66e10f75a4daadd9a1ba73dd6e3b731f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 12 Mar 2024 22:13:31 -0700
Subject: [PATCH 053/170] nrt

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

diff --git a/src/Analyzers/Core/CodeFixes/RemoveRedundantEquality/RemoveRedundantEqualityCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/RemoveRedundantEquality/RemoveRedundantEqualityCodeFixProvider.cs
index 6c5c51a7bba7b..15e00c76d5987 100644
--- a/src/Analyzers/Core/CodeFixes/RemoveRedundantEquality/RemoveRedundantEqualityCodeFixProvider.cs
+++ b/src/Analyzers/Core/CodeFixes/RemoveRedundantEquality/RemoveRedundantEqualityCodeFixProvider.cs
@@ -41,7 +41,7 @@ protected override async Task FixAsync(
         var generatorInternal = document.GetRequiredLanguageService<SyntaxGeneratorInternal>();
 
         var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
-        var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+        var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
         editor.ReplaceNode(node, WithElasticTrailingTrivia(RewriteNode()));
 

From 900a62abb5bc9188423ebeee4ddfc9ce35a1da0c Mon Sep 17 00:00:00 2001
From: Shen Chen <Cosifne@users.noreply.github.com>
Date: Tue, 12 Mar 2024 22:23:13 -0700
Subject: [PATCH 054/170] Use ProvideSettingsManifest to specify Unfied
 Settings registration file (#72429)

* Update versions

* Rename registration.json and add ProvideSettingsManifest

* Add name

* fix test

* Fix name

* Clean

* Add an entry in pkgdef

* Add comment

* Change csproj

* Fix source build

* Remove blank line

* Add comment

* Fix typo
---
 eng/Directory.Packages.props                  | 30 +++++++++----------
 eng/SourceBuildPrebuiltBaseline.xml           |  1 +
 eng/Version.Details.xml                       |  4 +++
 eng/Versions.props                            |  1 +
 .../TestUtilities/StubSettingsManagerHost.cs  |  7 ++++-
 src/VisualStudio/CSharp/Impl/CSharpPackage.cs |  1 +
 ...isualStudio.LanguageServices.CSharp.csproj |  1 +
 .../CSharp/Impl/PackageRegistration.pkgdef    |  7 +++++
 .../csharpSettings.registration.json}         |  4 +++
 .../Setup/Roslyn.VisualStudio.Setup.csproj    |  1 -
 10 files changed, 40 insertions(+), 17 deletions(-)
 rename src/VisualStudio/{Setup/UnifiedSettings/csharpIntellisenseSettings.registration.json => CSharp/Impl/UnifiedSettings/csharpSettings.registration.json} (96%)

diff --git a/eng/Directory.Packages.props b/eng/Directory.Packages.props
index 9a4458ff7537c..7c204fad33abc 100644
--- a/eng/Directory.Packages.props
+++ b/eng/Directory.Packages.props
@@ -43,9 +43,9 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(DotnetBuildFromSource)' != 'true' and '$(TargetFramework)' == 'net472'">
-    <PackageVersion Include="Microsoft.Build" Version="17.9.0-preview-23551-05" />
-    <PackageVersion Include="Microsoft.Build.Framework" Version="17.9.0-preview-23551-05" />
-    <PackageVersion Include="Microsoft.Build.Tasks.Core" Version="17.9.0-preview-23551-05" />
+    <PackageVersion Include="Microsoft.Build" Version="17.10.0-preview-24081-01" />
+    <PackageVersion Include="Microsoft.Build.Framework" Version="17.10.0-preview-24081-01" />
+    <PackageVersion Include="Microsoft.Build.Tasks.Core" Version="17.10.0-preview-24081-01" />
   </ItemGroup>
 
   <ItemGroup>
@@ -88,32 +88,32 @@
     <!--
       Subset of Microsoft.VisualStudio.Sdk meta-package (run `csi generate-vssdk-versions.csx` to update based on VSSDK meta-package).
     -->
-    <PackageVersion Include="Microsoft.VisualStudio.Composition" Version="17.7.29" />
+    <PackageVersion Include="Microsoft.VisualStudio.Composition" Version="17.10.11-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.CoreUtility" Version="17.9.80-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Editor" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.ImageCatalog" Version="17.9.35796-preview.1" />
-    <PackageVersion Include="Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime" Version="17.9.35796-preview.1" />
+    <PackageVersion Include="Microsoft.VisualStudio.ImageCatalog" Version="17.10.639-preview.1" />
+    <PackageVersion Include="Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime" Version="17.10.616-preview.1" />
     <PackageVersion Include="Microsoft.VisualStudio.Language.NavigateTo.Interfaces" Version="17.9.80-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.LanguageServer.Client" Version="17.9.25-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Language.StandardClassification" Version="17.9.80-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Language" Version="17.9.80-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.RemoteControl" Version="16.3.52" />
-    <PackageVersion Include="Microsoft.VisualStudio.RpcContracts" Version="17.9.5-alpha" />
-    <PackageVersion Include="Microsoft.VisualStudio.Shell.15.0" Version="17.9.35796-preview.1" />
-    <PackageVersion Include="Microsoft.VisualStudio.Telemetry" Version="17.9.13" />
+    <PackageVersion Include="Microsoft.VisualStudio.RpcContracts" Version="17.10.3-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Shell.15.0" Version="17.10.639-preview.1" />
+    <PackageVersion Include="Microsoft.VisualStudio.Telemetry" Version="17.10.4" />
     <PackageVersion Include="Microsoft.VisualStudio.Text.Data" Version="17.9.80-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Text.Logic" Version="17.9.80-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Text.UI" Version="17.9.80-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Text.UI.Wpf" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Threading" Version="17.9.3-alpha" />
+    <PackageVersion Include="Microsoft.VisualStudio.Threading" Version="17.10.12-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Utilities.Internal" Version="16.3.56" />
     <PackageVersion Include="Nerdbank.Streams" Version="2.10.69" />
     <PackageVersion Include="Newtonsoft.Json" Version="$(NewtonsoftJsonVersion)" />
-    <PackageVersion Include="StreamJsonRpc" Version="2.17.9" />
+    <PackageVersion Include="StreamJsonRpc" Version="2.18.6-preview" />
 
     <!-- TODO: workaround for https://github.com/dotnet/roslyn/issues/71377 -->
     <PackageVersion Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.10.12-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Composition.Analyzers" Version="17.7.40" />
+    <PackageVersion Include="Microsoft.VisualStudio.Composition.Analyzers" Version="17.10.11-preview" />
     <PackageVersion Include="Microsoft.ServiceHub.Framework" Version="4.4.22"/>
 
     <!--
@@ -188,7 +188,7 @@
     <PackageVersion Include="System.CommandLine" Version="$(SystemCommandLineVersion)" />
     <PackageVersion Include="System.Configuration.ConfigurationManager" Version="$(SystemConfigurationConfigurationManagerVersion)" />
     <PackageVersion Include="System.Composition" Version="$(SystemCompositionVersion)" />
-    <PackageVersion Include="System.ComponentModel.Composition" Version="7.0.0" />
+    <PackageVersion Include="System.ComponentModel.Composition" Version="8.0.0" />
     <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="$(SystemDiagnosticsDiagnosticSourceVersion)" />
     <PackageVersion Include="System.Diagnostics.EventLog" Version="$(SystemDiagnosticsEventLogVersion)" />
     <PackageVersion Include="System.IO.Hashing" Version="8.0.0" />
@@ -198,13 +198,13 @@
     <PackageVersion Include="System.Numerics.Vectors" Version="4.5.0" />
     <PackageVersion Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
     <PackageVersion Include="System.Runtime.Loader" Version="4.3.0" />
-    <PackageVersion Include="System.Resources.Extensions" Version="7.0.0" />
+    <PackageVersion Include="System.Resources.Extensions" Version="$(SystemResourcesExtensionsVersion)" />
     <PackageVersion Include="System.Security.Cryptography.ProtectedData" Version="$(SystemSecurityCryptographyProtectedDataVersion)" />
     <PackageVersion Include="System.Security.Permissions" Version="$(SystemSecurityPermissionsVersion)" />
     <PackageVersion Include="System.Security.Principal" Version="4.3.0" />
     <PackageVersion Include="System.Text.Encoding.CodePages" Version="7.0.0" />
     <PackageVersion Include="System.Text.Encoding.Extensions" Version="4.3.0" />
-    <PackageVersion Include="System.Threading.Tasks.Dataflow" Version="7.0.0" />
+    <PackageVersion Include="System.Threading.Tasks.Dataflow" Version="8.0.0" />
     <PackageVersion Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
     <PackageVersion Include="System.Windows.Extensions" Version="$(SystemWindowsExtensionsVersion)" />
 
diff --git a/eng/SourceBuildPrebuiltBaseline.xml b/eng/SourceBuildPrebuiltBaseline.xml
index 81d5528e6ec92..592d3954059e8 100644
--- a/eng/SourceBuildPrebuiltBaseline.xml
+++ b/eng/SourceBuildPrebuiltBaseline.xml
@@ -32,6 +32,7 @@
     <UsagePattern IdentityGlob="System.Configuration.ConfigurationManager/8.0*" />
     <UsagePattern IdentityGlob="System.Diagnostics.DiagnosticSource/8.0*" />
     <UsagePattern IdentityGlob="System.Diagnostics.EventLog/8.0*" />
+    <UsagePattern IdentityGlob="System.Resources.Extensions/8.0*" />
     <UsagePattern IdentityGlob="System.Security.Cryptography.ProtectedData/8.0*" />
     <UsagePattern IdentityGlob="System.Security.Permissions/8.0*" />
     <UsagePattern IdentityGlob="System.Text.Encodings.Web/8.0*" />
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index de5b5f80248b6..d281fce2ac599 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -72,6 +72,10 @@
       <Uri>https://github.com/dotnet/runtime</Uri>
       <Sha>5535e31a712343a63f5d7d796cd874e563e5ac14</Sha>
     </Dependency>
+    <Dependency Name="System.Resources.Extensions" Version="8.0.0">
+      <Uri>https://github.com/dotnet/runtime</Uri>
+      <Sha>5535e31a712343a63f5d7d796cd874e563e5ac14</Sha>
+    </Dependency>
     <Dependency Name="System.Text.Encodings.Web" Version="8.0.0">
       <Uri>https://github.com/dotnet/runtime</Uri>
       <Sha>5535e31a712343a63f5d7d796cd874e563e5ac14</Sha>
diff --git a/eng/Versions.props b/eng/Versions.props
index 0b7dc5299ca52..ca2c67bff31aa 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -28,6 +28,7 @@
     <SystemDiagnosticsDiagnosticSourceVersion>8.0.0</SystemDiagnosticsDiagnosticSourceVersion>
     <SystemIOPipelinesVersion>8.0.0</SystemIOPipelinesVersion>
     <SystemReflectionMetadataVersion>8.0.0</SystemReflectionMetadataVersion>
+    <SystemResourcesExtensionsVersion>8.0.0</SystemResourcesExtensionsVersion>
     <SystemSecurityCryptographyProtectedDataVersion>8.0.0</SystemSecurityCryptographyProtectedDataVersion>
     <SystemSecurityPermissionsVersion>8.0.0</SystemSecurityPermissionsVersion>
     <!-- Note: When updating SystemTextJsonVersion ensure that the version is no higher than what is used by MSBuild. -->
diff --git a/src/EditorFeatures/TestUtilities/StubSettingsManagerHost.cs b/src/EditorFeatures/TestUtilities/StubSettingsManagerHost.cs
index de4f0a5eb0dcc..d14ce4996f855 100644
--- a/src/EditorFeatures/TestUtilities/StubSettingsManagerHost.cs
+++ b/src/EditorFeatures/TestUtilities/StubSettingsManagerHost.cs
@@ -83,7 +83,7 @@ Task<Stream> ISettingsManagerHost5.GetServiceStreamAsync(string serviceMoniker,
         throw new NotImplementedException();
     }
 
-    private sealed class StringStorage : IStringStorage, IAsyncStringStorage
+    private sealed class StringStorage : IStringStorage2, IAsyncStringStorage
     {
         private ImmutableDictionary<string, VersionedString> _values = ImmutableDictionary<string, VersionedString>.Empty;
         private PropertyChangedEventHandler? _propertyChanged;
@@ -179,5 +179,10 @@ Task<ServiceUploadResult> IAsyncStringStorage.SetAsync(NamedVersionedString valu
         {
             throw new NotImplementedException();
         }
+
+        void IStringStorage2.ForEachSettingNameStartingWith(string prefix, CharSpanProcessorDelegate processFunc)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/src/VisualStudio/CSharp/Impl/CSharpPackage.cs b/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
index 78177323fcaa7..ccae4e77195f6 100644
--- a/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
+++ b/src/VisualStudio/CSharp/Impl/CSharpPackage.cs
@@ -53,6 +53,7 @@ namespace Microsoft.VisualStudio.LanguageServices.CSharp.LanguageService
     [ProvideLanguageEditorOptionPage(typeof(Options.Formatting.FormattingSpacingPage), "CSharp", @"Code Style\Formatting", "Spacing", pageNameResourceId: "#112", keywordListResourceId: 310)]
     [ProvideLanguageEditorOptionPage(typeof(Options.NamingStylesOptionPage), "CSharp", @"Code Style", "Naming", pageNameResourceId: "#115", keywordListResourceId: 314)]
     [ProvideLanguageEditorOptionPage(typeof(Options.IntelliSenseOptionPage), "CSharp", null, "IntelliSense", pageNameResourceId: "#103", keywordListResourceId: 312)]
+    [ProvideSettingsManifest(PackageRelativeManifestFile = @"UnifiedSettings\csharpSettings.registration.json")]
     [Guid(Guids.CSharpPackageIdString)]
     internal sealed class CSharpPackage : AbstractPackage<CSharpPackage, CSharpLanguageService>, IVsUserSettingsQuery
     {
diff --git a/src/VisualStudio/CSharp/Impl/Microsoft.VisualStudio.LanguageServices.CSharp.csproj b/src/VisualStudio/CSharp/Impl/Microsoft.VisualStudio.LanguageServices.CSharp.csproj
index c5cfdf4c133f7..6ff52d800af00 100644
--- a/src/VisualStudio/CSharp/Impl/Microsoft.VisualStudio.LanguageServices.CSharp.csproj
+++ b/src/VisualStudio/CSharp/Impl/Microsoft.VisualStudio.LanguageServices.CSharp.csproj
@@ -18,6 +18,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Content Update=".vsextension/string-resources.json" XlfPreserveFileName="true" />
+    <Content Include="UnifiedSettings/csharpSettings.registration.json" IncludeInVSIX="true" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
   <ItemGroup Label="PkgDef">
     <PkgDefInstalledProduct Include="{13c3bbb4-f18f-4111-9f54-a0fb010d9194}" Name="Microsoft Visual C#" DisplayName="#116" ProductDetails="#117" />
diff --git a/src/VisualStudio/CSharp/Impl/PackageRegistration.pkgdef b/src/VisualStudio/CSharp/Impl/PackageRegistration.pkgdef
index 1a7f62519f085..ee45c4813cee4 100644
--- a/src/VisualStudio/CSharp/Impl/PackageRegistration.pkgdef
+++ b/src/VisualStudio/CSharp/Impl/PackageRegistration.pkgdef
@@ -192,3 +192,10 @@
 "Package"="{13C3BBB4-F18F-4111-9F54-A0FB010D9194}"
 "SortPriority"=dword:00000064
 @="Microsoft Visual C#"
+
+// CacheTag value should be changed when registration file changes
+// See https://devdiv.visualstudio.com/DevDiv/_wiki/wikis/DevDiv.wiki/39345/Manifest-Build-Deployment-and-Setup-Authoring-In-Depth?anchor=example-pkgdef-key for more infomation
+[$RootKey$\SettingsManifests\{13c3bbb4-f18f-4111-9f54-a0fb010d9194}]
+@="Microsoft.VisualStudio.LanguageServices.CSharp.LanguageService.CSharpPackage"
+"ManifestPath"="$PackageFolder$\UnifiedSettings\csharpSettings.registration.json"
+"CacheTag"=qword:08DC1824DFE0117B
diff --git a/src/VisualStudio/Setup/UnifiedSettings/csharpIntellisenseSettings.registration.json b/src/VisualStudio/CSharp/Impl/UnifiedSettings/csharpSettings.registration.json
similarity index 96%
rename from src/VisualStudio/Setup/UnifiedSettings/csharpIntellisenseSettings.registration.json
rename to src/VisualStudio/CSharp/Impl/UnifiedSettings/csharpSettings.registration.json
index 2253fef5a7a06..a5a62ad827f35 100644
--- a/src/VisualStudio/Setup/UnifiedSettings/csharpIntellisenseSettings.registration.json
+++ b/src/VisualStudio/CSharp/Impl/UnifiedSettings/csharpSettings.registration.json
@@ -1,3 +1,7 @@
+// NOTE:
+// When this file is changed. Please also update the cache tag under settings entry in src/VisualStudio/CSharp/Impl/PackageRegistration.pkgdef
+// Otherwise your change might be ignored.
+// See https://devdiv.visualstudio.com/DevDiv/_wiki/wikis/DevDiv.wiki/39345/Manifest-Build-Deployment-and-Setup-Authoring-In-Depth?anchor=example-pkgdef-key for more details
 {
   "properties": {
     // CompletionOptionsStorage.TriggerOnTypingLetters
diff --git a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
index 9af768dba8071..ee3c8f5f5dc30 100644
--- a/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
+++ b/src/VisualStudio/Setup/Roslyn.VisualStudio.Setup.csproj
@@ -347,7 +347,6 @@
       <IncludeInVSIX>true</IncludeInVSIX>
       <Visible>false</Visible>
     </Content>
-    <Content Include="UnifiedSettings\*.registration.json" IncludeInVSIX="true" />
   </ItemGroup>
   <ItemGroup>
     <None Include="source.extension.vsixmanifest">

From 88bd6b2175efb8fb2415f62d30fbbfe5af942ca5 Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <Maryam.Ariyan@microsoft.com>
Date: Tue, 12 Mar 2024 22:40:08 -0700
Subject: [PATCH 055/170] Create analyzer reference once in ctor

---
 .../HostDiagnosticAnalyzerProvider.cs         | 39 ++++++-------------
 1 file changed, 12 insertions(+), 27 deletions(-)

diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
index dabf29f8ba48e..cbaa86c9589e5 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/HostDiagnosticAnalyzerProvider.cs
@@ -6,46 +6,31 @@
 using System.Reflection;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Workspaces.ProjectSystem;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 internal class HostDiagnosticAnalyzerProvider : IHostDiagnosticAnalyzerProvider
 {
-    /// <summary>
-    /// The full path to the Razor source generator
-    /// </summary>
-    public string? RazorSourceGenerator { get; set; }
 
-    private ImmutableArray<(AnalyzerFileReference reference, string extensionId)>? _cachedAnalyzerReferences;
+    private readonly ImmutableArray<(AnalyzerFileReference reference, string extensionId)> _analyzerReferences;
 
     public HostDiagnosticAnalyzerProvider(string? razorSourceGenerator)
     {
-        RazorSourceGenerator = razorSourceGenerator;
-    }
-
-    public ImmutableArray<(AnalyzerFileReference reference, string extensionId)> GetAnalyzerReferencesInExtensions()
-    {
-        if (_cachedAnalyzerReferences != null)
+        if (razorSourceGenerator == null || !File.Exists(razorSourceGenerator))
         {
-            return _cachedAnalyzerReferences.Value;
+            _analyzerReferences = ImmutableArray<(AnalyzerFileReference reference, string extensionId)>.Empty;
         }
-
-        if (RazorSourceGenerator == null)
+        else
         {
-            _cachedAnalyzerReferences = ImmutableArray<(AnalyzerFileReference reference, string extensionId)>.Empty;
-            return _cachedAnalyzerReferences.Value;
+            _analyzerReferences = ImmutableArray.Create<(AnalyzerFileReference reference, string extensionId)>((
+                new AnalyzerFileReference(razorSourceGenerator, new SimpleAnalyzerAssemblyLoader()),
+                ProjectSystemProject.RazorVsixExtensionId
+            ));
         }
+    }
 
-        var analyzerReferences = new List<(AnalyzerFileReference, string)>();
-
-        // Create an AnalyzerFileReference for each file
-        var analyzerReference = new AnalyzerFileReference(RazorSourceGenerator, new SimpleAnalyzerAssemblyLoader());
-
-        // Add the reference to the list, using the file name as the extension ID
-        analyzerReferences.Add((analyzerReference, ProjectSystemProject.RazorVsixExtensionId));
-
-        _cachedAnalyzerReferences = analyzerReferences.ToImmutableArray();
-        return _cachedAnalyzerReferences.Value;
+    public ImmutableArray<(AnalyzerFileReference reference, string extensionId)> GetAnalyzerReferencesInExtensions()
+    {
+        return _analyzerReferences;
     }
 
     private class SimpleAnalyzerAssemblyLoader : IAnalyzerAssemblyLoader

From c40aa6245bc6bdb6ef73ad7858f57f0ecf2c637c Mon Sep 17 00:00:00 2001
From: Jan Jones <janjones@microsoft.com>
Date: Wed, 13 Mar 2024 10:12:52 +0100
Subject: [PATCH 056/170] Suppress Lock conversion warnings when using object
 equality operators (#72459)

* Suppress Lock conversion warnings when using object equality operators

* Use `AccumulatesDiagnostics` helper

* Avoid resolving diagnostic code
---
 .../Portable/Binder/Binder_Operators.cs       |  34 +++++-
 .../CSharp/Test/Emit2/Semantics/LockTests.cs  | 100 ++++++++++++++++++
 .../Portable/Binding/Binder_Operators.vb      |  34 +++++-
 .../Test/Semantic/Binding/SyncLockTests.vb    |  85 +++++++++++++++
 4 files changed, 249 insertions(+), 4 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
index 4e4347eba66c6..40acd645365d9 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs
@@ -637,8 +637,38 @@ private BoundExpression BindSimpleBinaryOperator(BinaryExpressionSyntax node, Bi
                 Debug.Assert((object)signature.LeftType != null);
                 Debug.Assert((object)signature.RightType != null);
 
-                resultLeft = CreateConversion(left, best.LeftConversion, signature.LeftType, diagnostics);
-                resultRight = CreateConversion(right, best.RightConversion, signature.RightType, diagnostics);
+                // If this is an object equality operator, we will suppress Lock conversion warnings.
+                var needsFilterDiagnostics =
+                    resultOperatorKind is BinaryOperatorKind.ObjectEqual or BinaryOperatorKind.ObjectNotEqual &&
+                    diagnostics.AccumulatesDiagnostics;
+                var conversionDiagnostics = needsFilterDiagnostics ? BindingDiagnosticBag.GetInstance(template: diagnostics) : diagnostics;
+
+                resultLeft = CreateConversion(left, best.LeftConversion, signature.LeftType, conversionDiagnostics);
+                resultRight = CreateConversion(right, best.RightConversion, signature.RightType, conversionDiagnostics);
+
+                if (needsFilterDiagnostics)
+                {
+                    Debug.Assert(conversionDiagnostics != diagnostics);
+                    diagnostics.AddDependencies(conversionDiagnostics);
+
+                    var sourceBag = conversionDiagnostics.DiagnosticBag;
+                    Debug.Assert(sourceBag is not null);
+
+                    if (!sourceBag.IsEmptyWithoutResolution)
+                    {
+                        foreach (var diagnostic in sourceBag.AsEnumerableWithoutResolution())
+                        {
+                            var code = diagnostic is DiagnosticWithInfo { HasLazyInfo: true, LazyInfo.Code: var lazyCode } ? lazyCode : diagnostic.Code;
+                            if ((ErrorCode)code is not ErrorCode.WRN_ConvertingLock)
+                            {
+                                diagnostics.Add(diagnostic);
+                            }
+                        }
+                    }
+
+                    conversionDiagnostics.Free();
+                }
+
                 resultConstant = FoldBinaryOperator(node, resultOperatorKind, resultLeft, resultRight, resultType, diagnostics);
             }
             else
diff --git a/src/Compilers/CSharp/Test/Emit2/Semantics/LockTests.cs b/src/Compilers/CSharp/Test/Emit2/Semantics/LockTests.cs
index 392bfa04527f5..61b08bdf399e5 100644
--- a/src/Compilers/CSharp/Test/Emit2/Semantics/LockTests.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Semantics/LockTests.cs
@@ -1748,6 +1748,106 @@ .locals init (System.Threading.Lock.Scope V_0)
             """);
     }
 
+    [Fact]
+    public void ObjectEquality()
+    {
+        var source = """
+            #nullable enable
+            using System;
+            using System.Threading;
+
+            static class C
+            {
+                static void Main()
+                {
+                    Lock? l = new();
+                    if (l != null)
+                    {
+                        lock (l) { Console.Write("1"); }
+                    }
+                    if (l == null)
+                    {
+                        throw null!;
+                    }
+                    if (l is { })
+                    {
+                        lock (l) { Console.Write("2"); }
+                    }
+                    if (l is { } l2)
+                    {
+                        lock (l2) { Console.Write("3"); }
+                    }
+                    if (l is not { })
+                    {
+                        throw null!;
+                    }
+                    if (l is null)
+                    {
+                        throw null!;
+                    }
+                    if (l is not null)
+                    {
+                        lock (l) { Console.Write("4"); }
+                    }
+                    if (l is not null and var l3)
+                    {
+                        lock (l3) { Console.Write("5"); }
+                    }
+                    if (null != l)
+                    {
+                        lock (l) { Console.Write("6"); }
+                    }
+                    if (null == l)
+                    {
+                        throw null!;
+                    }
+                    if (!(l == null))
+                    {
+                        lock (l) { Console.Write("7"); }
+                    }
+                    if (!(l != null))
+                    {
+                        throw null!;
+                    }
+
+                    Lock? l4 = new();
+                    if (l == l4)
+                    {
+                        throw null!;
+                    }
+                    if (l != l4)
+                    {
+                        lock (l4) { Console.Write("8"); }
+                    }
+                    if (ReferenceEquals(l, l4))
+                    {
+                        throw null!;
+                    }
+                    if (((object)l) == l4)
+                    {
+                        throw null!;
+                    }
+                    if (l == new Lock())
+                    {
+                        throw null!;
+                    }
+                }
+            }
+            """;
+        var verifier = CompileAndVerify([source, LockTypeDefinition], verify: Verification.FailsILVerify,
+            expectedOutput: "E1DE2DE3DE4DE5DE6DE7DE8D");
+        verifier.VerifyDiagnostics(
+            // (68,29): warning CS9216: A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in 'lock' statement.
+            //         if (ReferenceEquals(l, l4))
+            Diagnostic(ErrorCode.WRN_ConvertingLock, "l").WithLocation(68, 29),
+            // (68,32): warning CS9216: A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in 'lock' statement.
+            //         if (ReferenceEquals(l, l4))
+            Diagnostic(ErrorCode.WRN_ConvertingLock, "l4").WithLocation(68, 32),
+            // (72,22): warning CS9216: A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in 'lock' statement.
+            //         if (((object)l) == l4)
+            Diagnostic(ErrorCode.WRN_ConvertingLock, "l").WithLocation(72, 22));
+    }
+
     [Fact]
     public void Await()
     {
diff --git a/src/Compilers/VisualBasic/Portable/Binding/Binder_Operators.vb b/src/Compilers/VisualBasic/Portable/Binding/Binder_Operators.vb
index e9988e68415b8..99cb7ac6d1ad8 100644
--- a/src/Compilers/VisualBasic/Portable/Binding/Binder_Operators.vb
+++ b/src/Compilers/VisualBasic/Portable/Binding/Binder_Operators.vb
@@ -38,8 +38,38 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             left = MakeRValue(left, diagnostics)
             right = MakeRValue(right, diagnostics)
 
-            left = ValidateAndConvertIsExpressionArgument(left, right, [isNot], diagnostics)
-            right = ValidateAndConvertIsExpressionArgument(right, left, [isNot], diagnostics)
+            ' Suppress Lock conversion warnings for Is operator.
+            Dim needsFilterDiagnostics = diagnostics.AccumulatesDiagnostics
+            Dim conversionDiagnostics = If(needsFilterDiagnostics, BindingDiagnosticBag.GetInstance(diagnostics), diagnostics)
+
+            left = ValidateAndConvertIsExpressionArgument(left, right, [isNot], conversionDiagnostics)
+            right = ValidateAndConvertIsExpressionArgument(right, left, [isNot], conversionDiagnostics)
+
+            If needsFilterDiagnostics Then
+                Debug.Assert(conversionDiagnostics IsNot diagnostics)
+                diagnostics.AddDependencies(conversionDiagnostics)
+
+                Dim sourceBag = conversionDiagnostics.DiagnosticBag
+                Debug.Assert(sourceBag IsNot Nothing)
+
+                If Not sourceBag.IsEmptyWithoutResolution Then
+                    For Each diagnostic In sourceBag.AsEnumerableWithoutResolution()
+                        Dim code As Integer
+                        Dim diagnosticWithInfo = TryCast(diagnostic, DiagnosticWithInfo)
+                        If diagnosticWithInfo IsNot Nothing AndAlso diagnosticWithInfo.HasLazyInfo Then
+                            code = diagnosticWithInfo.LazyInfo.Code
+                        Else
+                            code = diagnostic.Code
+                        End If
+
+                        If code <> ERRID.WRN_ConvertingLock Then
+                            diagnostics.Add(diagnostic)
+                        End If
+                    Next
+                End If
+
+                conversionDiagnostics.Free()
+            End If
 
             Dim result As BoundExpression
             Dim booleanType = GetSpecialType(SpecialType.System_Boolean, node, diagnostics)
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Binding/SyncLockTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Binding/SyncLockTests.vb
index 98f71f7808904..fff1e134bbdcb 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Binding/SyncLockTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Binding/SyncLockTests.vb
@@ -984,5 +984,90 @@ BC42508: A value of type 'System.Threading.Lock' converted to a different type w
   IL_002b:  ret
 }]]>)
         End Sub
+
+        <Fact>
+        Public Sub LockType_ObjectEquality()
+            Dim source = <![CDATA[
+Imports System
+Imports System.Threading
+
+Module Program
+    Sub Main()
+        Dim l As Lock = New Lock()
+
+        If l IsNot Nothing Then
+            Console.Write("1")
+        End If
+
+        If l Is Nothing Then
+            Throw New Exception
+        End If
+
+        If l IsNot Nothing Then
+            Console.Write("2")
+        End If
+
+        If l Is Nothing Then
+            Throw New Exception
+        End If
+
+        If Not (l Is Nothing) Then
+            Console.Write("3")
+        End If
+
+        If Not (l IsNot Nothing) Then
+            Throw New Exception
+        End If
+
+        Dim l2 As Lock = New Lock()
+
+        If l Is l2 Then
+            Throw New Exception
+        End If
+
+        If l IsNot l2 Then
+            Console.Write("4")
+        End If
+
+        If ReferenceEquals(l, l2) Then
+            Throw New Exception
+        End If
+
+        If (CObj(l)) Is l2 Then
+            Throw New Exception
+        End If
+
+        If (CObj(l)) IsNot l2 Then
+            Console.Write("5")
+        End If
+
+        If l Is New Lock() Then
+            Throw New Exception
+        End If
+    End Sub
+End Module
+
+Namespace System.Threading
+    Public Class Lock
+    End Class
+End Namespace
+]]>.Value
+            Dim comp = CreateCompilation(source, options:=TestOptions.ReleaseExe)
+            Dim verifier = CompileAndVerify(comp, expectedOutput:="12345")
+            verifier.Diagnostics.AssertTheseDiagnostics(<![CDATA[
+BC42508: A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in SyncLock statement.
+        If ReferenceEquals(l, l2) Then
+                           ~
+BC42508: A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in SyncLock statement.
+        If ReferenceEquals(l, l2) Then
+                              ~~
+BC42508: A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in SyncLock statement.
+        If (CObj(l)) Is l2 Then
+                 ~
+BC42508: A value of type 'System.Threading.Lock' converted to a different type will use likely unintended monitor-based locking in SyncLock statement.
+        If (CObj(l)) IsNot l2 Then
+                 ~
+]]>)
+        End Sub
     End Class
 End Namespace

From 9be4c180382a6981a2738f2174f79c5cea967634 Mon Sep 17 00:00:00 2001
From: DoctorKrolic <70431552+DoctorKrolic@users.noreply.github.com>
Date: Wed, 13 Mar 2024 12:43:16 +0300
Subject: [PATCH 057/170] Fix doc comment (#72514)

---
 src/Compilers/Core/Portable/Symbols/ISymbol.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/Compilers/Core/Portable/Symbols/ISymbol.cs b/src/Compilers/Core/Portable/Symbols/ISymbol.cs
index 285f1ac0efc40..1c461b0825233 100644
--- a/src/Compilers/Core/Portable/Symbols/ISymbol.cs
+++ b/src/Compilers/Core/Portable/Symbols/ISymbol.cs
@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
@@ -191,7 +190,7 @@ public interface ISymbol : IEquatable<ISymbol?>
         ImmutableArray<SyntaxReference> DeclaringSyntaxReferences { get; }
 
         /// <summary>
-        /// Gets the attributes for the symbol. Returns an empty <see cref="IEnumerable{ISymbolAttribute}"/>
+        /// Gets the attributes for the symbol. Returns an empty <see cref="ImmutableArray{AttributeData}"/>
         /// if there are no attributes.
         /// </summary>
         ImmutableArray<AttributeData> GetAttributes();

From 7537f719ac70eb3a8985d988c25c65b2065e9162 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 13 Mar 2024 07:55:15 -0700
Subject: [PATCH 058/170] Add back interface used by TypeScript

---
 .../IWorkCoordinatorPriorityService.cs        | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 src/Features/Core/Portable/SolutionCrawler/IWorkCoordinatorPriorityService.cs

diff --git a/src/Features/Core/Portable/SolutionCrawler/IWorkCoordinatorPriorityService.cs b/src/Features/Core/Portable/SolutionCrawler/IWorkCoordinatorPriorityService.cs
new file mode 100644
index 0000000000000..63ab88a486703
--- /dev/null
+++ b/src/Features/Core/Portable/SolutionCrawler/IWorkCoordinatorPriorityService.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Host;
+
+namespace Microsoft.CodeAnalysis.SolutionCrawler;
+
+[Obsolete("Remove your implementation of this interface and let Roslyn know so that this interface can be removed.", error: false)]
+internal interface IWorkCoordinatorPriorityService : ILanguageService
+{
+    /// <summary>
+    /// True if this document is less important than other documents in the project it is 
+    /// contained in, and should have work scheduled for it happen after all other documents
+    /// in the project.
+    /// </summary>
+    Task<bool> IsLowPriorityAsync(Document document, CancellationToken cancellationToken);
+}

From 32dfeb4e8c27268cfbdcb424c33966629202b144 Mon Sep 17 00:00:00 2001
From: sdelarosbil <sdelarosbil@spiria.com>
Date: Wed, 13 Mar 2024 12:44:52 -0400
Subject: [PATCH 059/170] Address code review style comments

---
 .../Providers/AbstractDocCommentCompletionProvider.cs     | 8 ++++++--
 .../XmlDocCommentCompletionProvider.vb                    | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
index 3ee0db19310bc..63ffe67ded854 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
@@ -115,8 +115,12 @@ private CompletionItem GetItem(string name)
 
     protected IEnumerable<CompletionItem> GetAttributeItems(string tagName, ISet<string> existingAttributes, bool addEqualsAndQuotes)
     {
-        return s_attributeMap.Where(x => x.elementName == tagName && !existingAttributes.Contains(x.attributeName))
-                             .Select(x => CreateCompletionItem(x.attributeName, beforeCaretText: addEqualsAndQuotes ? x.text : x.text[..^2], afterCaretText: addEqualsAndQuotes ? "\"" : ""));
+        return s_attributeMap
+            .Where(x => x.elementName == tagName && !existingAttributes.Contains(x.attributeName))
+            .Select(x => CreateCompletionItem(
+                x.attributeName,
+                beforeCaretText: addEqualsAndQuotes ? x.text : x.text[..^2],
+                afterCaretText: addEqualsAndQuotes ? "\"" : ""));
     }
 
     protected IEnumerable<CompletionItem> GetAlwaysVisibleItems()
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
index 90fd3b9404964..3f81d4ed53984 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
@@ -332,7 +332,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
 
         Private Function GetAttributes(tagName As String, attributes As SyntaxList(Of XmlNodeSyntax)) As IEnumerable(Of CompletionItem)
             Dim existingAttributeNames = attributes.Select(AddressOf GetAttributeName).WhereNotNull().ToSet()
-            Return GetAttributeItems(tagName, existingAttributeNames, false)
+            Return GetAttributeItems(tagName, existingAttributeNames, addEqualsAndQuotes := false)
         End Function
 
         Private Shared Function GetAttributeName(node As XmlNodeSyntax) As String

From bb16de62ce02e47d335bfaf0e2cd8b301f5c90f4 Mon Sep 17 00:00:00 2001
From: sdelarosbil <sdelarosbil@spiria.com>
Date: Wed, 13 Mar 2024 12:45:43 -0400
Subject: [PATCH 060/170] Move tests to CompletionCommandHandler and add
 equals/quotes if there's trivia

---
 ...mentationCommentCompletionProviderTests.cs | 17 -------
 ...arpCompletionCommandHandlerTests_XmlDoc.vb | 48 +++++++++++++++++++
 .../XmlDocCommentCompletionProvider.cs        |  4 +-
 .../AbstractDocCommentCompletionProvider.cs   |  7 +++
 4 files changed, 58 insertions(+), 18 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
index 94ca88f585996..09c7f1c4cc4dd 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
@@ -1044,23 +1044,6 @@ void Goo() { }
             await VerifyItemExistsAsync(text, "langword");
         }
 
-        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/11489")]
-        public async Task AttributeValueOnQuote()
-        {
-            var text = """
-                class C
-                {
-                    /// <summary>
-                    /// <see langword="$$
-                    /// </summary>
-                    static void Goo()
-                    {
-                    }
-                }
-                """;
-            await VerifyItemExistsAsync(text, "await", usePreviousCharAsTrigger: true);
-        }
-
         [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/757")]
         public async Task TermAndDescriptionInsideItem()
         {
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_XmlDoc.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_XmlDoc.vb
index 66114aabbdd26..0516b2c762a78 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_XmlDoc.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_XmlDoc.vb
@@ -625,6 +625,54 @@ class c
             End Using
         End Function
 
+        <WpfTheory, CombinatorialData>
+        Public Async Function InvokeWithOpenAngleSeeCommitLangwordWithEqualsQuotes(showCompletionInArgumentLists As Boolean) As Task
+
+            Using state = TestStateFactory.CreateCSharpTestState(
+                <Document><![CDATA[
+class c
+{
+    /// <summary>
+    /// <see $$=""
+    /// </summary>
+    void goo() { }
+}
+            ]]></Document>, showCompletionInArgumentLists:=showCompletionInArgumentLists)
+
+                state.SendTypeChars("l")
+                state.SendInvokeCompletionList()
+                Await state.AssertSelectedCompletionItem(displayText:="langword")
+                state.SendReturn()
+
+                ' /// <see langword="$$"/>
+                Await state.AssertLineTextAroundCaret("    /// <see langword=""", """")
+            End Using
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        Public Async Function InvokeWithOpenAngleSeeCommitLangwordWithSpaceEqualsQuotes(showCompletionInArgumentLists As Boolean) As Task
+
+            Using state = TestStateFactory.CreateCSharpTestState(
+                <Document><![CDATA[
+class c
+{
+    /// <summary>
+    /// <see $$ =""
+    /// </summary>
+    void goo() { }
+}
+            ]]></Document>, showCompletionInArgumentLists:=showCompletionInArgumentLists)
+
+                state.SendTypeChars("l")
+                state.SendInvokeCompletionList()
+                Await state.AssertSelectedCompletionItem(displayText:="langword")
+                state.SendReturn()
+
+                ' /// <see langword="$$"/>
+                Await state.AssertLineTextAroundCaret("    /// <see langword=""", """ =""""")
+            End Using
+        End Function
+
         <WpfTheory, CombinatorialData>
         Public Function InvokeWithNullKeywordCommitSeeLangword(showCompletionInArgumentLists As Boolean) As Task
             Return InvokeWithKeywordCommitSeeLangword("null", showCompletionInArgumentLists)
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
index dd6028ec8a342..b950e664dfc13 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.cs
@@ -85,7 +85,9 @@ public override bool IsInsertionTrigger(SourceText text, int characterPosition,
 
             if (IsAttributeNameContext(token, position, out var elementName, out var existingAttributes))
             {
-                return GetAttributeItems(elementName, existingAttributes, !token.GetNextToken().IsKind(SyntaxKind.EqualsToken));
+                var nextToken = token.GetNextToken();
+                return GetAttributeItems(elementName, existingAttributes,
+                    addEqualsAndQuotes: !nextToken.IsKind(SyntaxKind.EqualsToken) || nextToken.HasLeadingTrivia);
             }
 
             var wasTriggeredAfterSpace = trigger.Kind == CompletionTriggerKind.Insertion && trigger.Character == ' ';
diff --git a/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
index 63ffe67ded854..0351f0944b2cb 100644
--- a/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/AbstractDocCommentCompletionProvider.cs
@@ -283,6 +283,13 @@ public override async Task<CompletionChange> GetChangeAsync(Document document, C
         var replacementText = beforeCaretText;
         var newPosition = replacementSpan.Start + beforeCaretText.Length;
 
+        if (text.Length > replacementSpan.End + 1
+            && text[replacementSpan.End] == '='
+            && text[replacementSpan.End + 1] == '"')
+        {
+            newPosition += 2;
+        }
+
         if (commitChar.HasValue && !char.IsWhiteSpace(commitChar.Value) && commitChar.Value != replacementText[^1])
         {
             // include the commit character

From 35abb420e7006195d8696eaf478b020d76510e7a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 13 Mar 2024 11:24:57 -0700
Subject: [PATCH 061/170] Do not report unchanged files in workspace-pull
 diagnostics

---
 .../AbstractPullDiagnosticHandler.cs          | 29 ++++++++++++-------
 ...AbstractWorkspacePullDiagnosticsHandler.cs |  3 ++
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
index e3869cb792c71..7e43bed13a75c 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
@@ -20,16 +20,17 @@
 
 namespace Microsoft.CodeAnalysis.LanguageServer.Handler.Diagnostics
 {
-    internal abstract class AbstractDocumentPullDiagnosticHandler<TDiagnosticsParams, TReport, TReturn>
-        : AbstractPullDiagnosticHandler<TDiagnosticsParams, TReport, TReturn>, ITextDocumentIdentifierHandler<TDiagnosticsParams, TextDocumentIdentifier?>
+    internal abstract class AbstractDocumentPullDiagnosticHandler<TDiagnosticsParams, TReport, TReturn>(
+        IDiagnosticAnalyzerService diagnosticAnalyzerService,
+        IDiagnosticsRefresher diagnosticRefresher,
+        IGlobalOptionService globalOptions)
+        : AbstractPullDiagnosticHandler<TDiagnosticsParams, TReport, TReturn>(
+            diagnosticAnalyzerService,
+            diagnosticRefresher,
+            globalOptions), ITextDocumentIdentifierHandler<TDiagnosticsParams, TextDocumentIdentifier?>
         where TDiagnosticsParams : IPartialResultParams<TReport>
     {
-        public AbstractDocumentPullDiagnosticHandler(
-            IDiagnosticAnalyzerService diagnosticAnalyzerService,
-            IDiagnosticsRefresher diagnosticRefresher,
-            IGlobalOptionService globalOptions) : base(diagnosticAnalyzerService, diagnosticRefresher, globalOptions)
-        {
-        }
+        protected sealed override bool IsWorkspacePullDiagnosticsHandler => false;
 
         public abstract LSP.TextDocumentIdentifier? GetTextDocumentIdentifier(TDiagnosticsParams diagnosticsParams);
     }
@@ -80,6 +81,8 @@ protected AbstractPullDiagnosticHandler(
             GlobalOptions = globalOptions;
         }
 
+        protected abstract bool IsWorkspacePullDiagnosticsHandler { get; }
+
         protected virtual string? GetDiagnosticSourceIdentifier(TDiagnosticsParams diagnosticsParams) => null;
 
         /// <summary>
@@ -187,8 +190,14 @@ await ComputeAndReportCurrentDiagnosticsAsync(
                     // Nothing changed between the last request and this one.  Report a (null-diagnostics,
                     // same-result-id) response to the client as that means they should just preserve the current
                     // diagnostics they have for this file.
-                    var previousParams = documentToPreviousDiagnosticParams[diagnosticSource.GetId()];
-                    progress.Report(CreateUnchangedReport(previousParams.TextDocument, previousParams.PreviousResultId));
+                    //
+                    // Note: if this is a workspace request, we can do nothing, as that will be interpreted by the
+                    // client as nothing having been changed for that document.
+                    if (!this.IsWorkspacePullDiagnosticsHandler)
+                    {
+                        var previousParams = documentToPreviousDiagnosticParams[diagnosticSource.GetId()];
+                        progress.Report(CreateUnchangedReport(previousParams.TextDocument, previousParams.PreviousResultId));
+                    }
                 }
             }
 
diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs
index ce0f46cbc792e..70b041533b350 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs
@@ -18,6 +18,7 @@
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.LanguageServer.Handler.Diagnostics;
+
 internal abstract class AbstractWorkspacePullDiagnosticsHandler<TDiagnosticsParams, TReport, TReturn>
     : AbstractPullDiagnosticHandler<TDiagnosticsParams, TReport, TReturn>, IDisposable
     where TDiagnosticsParams : IPartialResultParams<TReport>
@@ -33,6 +34,8 @@ internal abstract class AbstractWorkspacePullDiagnosticsHandler<TDiagnosticsPara
     /// </summary>
     private int _lspChanged = 0;
 
+    protected sealed override bool IsWorkspacePullDiagnosticsHandler => true;
+
     protected AbstractWorkspacePullDiagnosticsHandler(
         LspWorkspaceManager workspaceManager,
         LspWorkspaceRegistrationService registrationService,

From 72396c069d0861142612e13b4ca8a24f30ae2c37 Mon Sep 17 00:00:00 2001
From: Stuart Lang <stuart.b.lang@gmail.com>
Date: Wed, 13 Mar 2024 11:43:40 -0700
Subject: [PATCH 062/170] Remove redundant feature (#72525)

---
 docs/Language Feature Status.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/docs/Language Feature Status.md b/docs/Language Feature Status.md
index b7651f0632ca6..4fbf571e12e5b 100644
--- a/docs/Language Feature Status.md	
+++ b/docs/Language Feature Status.md	
@@ -12,7 +12,6 @@ efforts behind them.
 | ------- | ------ | ----- | --------- | -------- | --------- | --------- |
 | [Ref Struct Interfaces](https://github.com/dotnet/csharplang/issues/7608) | [RefStructInterfaces](https://github.com/dotnet/roslyn/tree/features/RefStructInterfaces) | [In Progress](https://github.com/dotnet/roslyn/issues/72124) | [AlekseyTs](https://github.com/AlekseyTs) | [cston](https://github.com/cston), [jjonescz](https://github.com/jjonescz) |  |  [agocke](https://github.com/agocke), [jaredpar](https://github.com/jaredpar) |
 | [Semi-auto-properties](https://github.com/dotnet/csharplang/issues/140) | [semi-auto-props](https://github.com/dotnet/roslyn/tree/features/semi-auto-props) | [In Progress](https://github.com/dotnet/roslyn/issues/57012) | [Youssef1313](https://github.com/Youssef1313) | [333fred](https://github.com/333fred), [RikkiGibson](https://github.com/RikkiGibson) |  | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) |
-| [Params Span\<T> + Stackalloc any array type](https://github.com/dotnet/csharplang/issues/1757) | [params-span](https://github.com/dotnet/roslyn/tree/features/params-span) | [In Progress](https://github.com/dotnet/roslyn/issues/57049) | [cston](https://github.com/cston) | TBD |  | [jaredpar](https://github.com/jaredpar) |
 | [Default in deconstruction](https://github.com/dotnet/roslyn/pull/25562) | [decon-default](https://github.com/dotnet/roslyn/tree/features/decon-default) | [In Progress](https://github.com/dotnet/roslyn/issues/25559) | [jcouv](https://github.com/jcouv) | [gafter](https://github.com/gafter) |  | [jcouv](https://github.com/jcouv) |
 | [Roles/Extensions](https://github.com/dotnet/csharplang/issues/5497) | [roles](https://github.com/dotnet/roslyn/tree/features/roles) | [In Progress](https://github.com/dotnet/roslyn/issues/66722) | [jcouv](https://github.com/jcouv) | [AlekseyTs](https://github.com/AlekseyTs), [jjonescz](https://github.com/jjonescz) |  | [MadsTorgersen](https://github.com/MadsTorgersen) |
 | [Escape character](https://github.com/dotnet/csharplang/issues/7400) | N/A | [Merged into 17.9p1](https://github.com/dotnet/roslyn/pull/70497) | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | [jcouv](https://github.com/jcouv), [RikkiGibson](https://github.com/RikkiGibson) |  | [CyrusNajmabadi](https://github.com/CyrusNajmabadi) | 

From ac8e4377b82925ebb4c4994230b4a6617488ed7c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 13 Mar 2024 11:36:57 -0700
Subject: [PATCH 063/170] Update tests

---
 .../Diagnostics/PullDiagnosticTests.cs        | 48 ++++++-------------
 1 file changed, 15 insertions(+), 33 deletions(-)

diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs
index 418de519f20c1..63cb36498c2ad 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs
@@ -1347,14 +1347,8 @@ public async Task TestNoChangeIfWorkspaceDiagnosticsCalledTwice(bool useVSDiagno
 
             var results2 = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics, previousResults: CreateDiagnosticParamsFromPreviousReports(results));
 
-            Assert.Equal(3, results2.Length);
-            Assert.Null(results2[0].Diagnostics);
-            Assert.Null(results2[1].Diagnostics);
-            Assert.Null(results2[2].Diagnostics);
-
-            Assert.Equal(results[0].ResultId, results2[0].ResultId);
-            Assert.Equal(results[1].ResultId, results2[1].ResultId);
-            Assert.Equal(results[2].ResultId, results2[2].ResultId);
+            // 'no changes' will be reported as an empty array.
+            Assert.Empty(results2);
         }
 
         [Theory, CombinatorialData]
@@ -1657,19 +1651,14 @@ public class {|caret:|} { }
             var previousResultIds = CreateDiagnosticParamsFromPreviousReports(results);
             results = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics, previousResultIds);
             AssertEx.NotNull(results);
-            Assert.Equal(4, results.Length);
-
-            // Verify the diagnostic result for A.cs is unchanged as A.cs does not reference CSProj2.
-            Assert.Null(results[0].Diagnostics);
-            Assert.Equal(previousResultIds[0].resultId, results[0].ResultId);
-            Assert.Null(results[1].Diagnostics);
-            Assert.Equal(previousResultIds[1].resultId, results[1].ResultId);
+            Assert.Equal(2, results.Length);
 
+            // Note: tehre will be no results for A.cs as it is unchanged and does not reference CSProj2.
             // Verify that the diagnostics result for B.cs reflects the change we made to it.
-            Assert.Empty(results[2].Diagnostics);
-            Assert.NotEqual(previousResultIds[2].resultId, results[2].ResultId);
-            Assert.Empty(results[3].Diagnostics);
-            Assert.NotEqual(previousResultIds[3].resultId, results[3].ResultId);
+            Assert.Empty(results[0].Diagnostics);
+            Assert.NotEqual(previousResultIds[2].resultId, results[0].ResultId);
+            Assert.Empty(results[1].Diagnostics);
+            Assert.NotEqual(previousResultIds[3].resultId, results[1].ResultId);
         }
 
         [Theory, CombinatorialData]
@@ -1728,7 +1717,7 @@ public class {|caret:|} { }
         }
 
         [Theory, CombinatorialData]
-        public async Task TestWorkspaceDiagnosticsWithDependentProjectReloadedUnChanged(bool useVSDiagnostics, bool mutatingLspWorkspace)
+        public async Task TestWorkspaceDiagnosticsWithDependentProjectReloadedUnchanged(bool useVSDiagnostics, bool mutatingLspWorkspace)
         {
             var markup1 =
 @"namespace M
@@ -1774,14 +1763,10 @@ public class {|caret:|} { }
             results = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics, previousResults: previousResultIds);
 
             // Verify that since no actual changes have been made we report unchanged diagnostics.
+            // We get an empty array here as this is workspace diagnostics, and we do not report unchanged
+            // docs there for efficiency.
             AssertEx.NotNull(results);
-            Assert.Equal(4, results.Length);
-
-            // Diagnostics should be unchanged as the referenced project was only unloaded / reloaded, but did not actually change.
-            Assert.Null(results[0].Diagnostics);
-            Assert.Equal(previousResultIds[0].resultId, results[0].ResultId);
-            Assert.Null(results[2].Diagnostics);
-            Assert.Equal(previousResultIds[2].resultId, results[2].ResultId);
+            Assert.Empty(results);
         }
 
         [Theory, CombinatorialData]
@@ -1830,13 +1815,10 @@ class A : B { }
             results = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics, previousResults: previousResults);
 
             // Verify that since no actual changes have been made we report unchanged diagnostics.
+            // We get an empty array here as this is workspace diagnostics, and we do not report unchanged
+            // docs there for efficiency.
             AssertEx.NotNull(results);
-            Assert.Equal(6, results.Length);
-
-            // Diagnostics should be unchanged as a referenced project was unloaded and reloaded.  Order should not matter.
-            Assert.Null(results[0].Diagnostics);
-            Assert.All(results, result => Assert.Null(result.Diagnostics));
-            Assert.All(results, result => Assert.True(previousResultIds.Contains(result.ResultId)));
+            Assert.Empty(results);
         }
 
         [Theory, CombinatorialData]

From ad9182d9fe06e1ad7310e772a8467c9cf41139a3 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 13 Mar 2024 11:58:29 -0700
Subject: [PATCH 064/170] Change how we report htings

---
 .../AbstractPullDiagnosticHandler.cs          | 19 +++++++----------
 ...AbstractWorkspacePullDiagnosticsHandler.cs |  2 --
 .../DocumentPullDiagnosticHandler.cs          |  7 +++++--
 .../PublicDocumentPullDiagnosticsHandler.cs   |  9 +++++---
 .../PublicWorkspacePullDiagnosticsHandler.cs  | 21 +++++++------------
 .../WorkspacePullDiagnosticHandler.cs         | 10 +++++++--
 6 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
index 7e43bed13a75c..a0d11561d04c6 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
@@ -6,6 +6,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -30,8 +31,6 @@ internal abstract class AbstractDocumentPullDiagnosticHandler<TDiagnosticsParams
             globalOptions), ITextDocumentIdentifierHandler<TDiagnosticsParams, TextDocumentIdentifier?>
         where TDiagnosticsParams : IPartialResultParams<TReport>
     {
-        protected sealed override bool IsWorkspacePullDiagnosticsHandler => false;
-
         public abstract LSP.TextDocumentIdentifier? GetTextDocumentIdentifier(TDiagnosticsParams diagnosticsParams);
     }
 
@@ -81,8 +80,6 @@ protected AbstractPullDiagnosticHandler(
             GlobalOptions = globalOptions;
         }
 
-        protected abstract bool IsWorkspacePullDiagnosticsHandler { get; }
-
         protected virtual string? GetDiagnosticSourceIdentifier(TDiagnosticsParams diagnosticsParams) => null;
 
         /// <summary>
@@ -103,9 +100,11 @@ protected abstract ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagno
         protected abstract TReport CreateReport(TextDocumentIdentifier identifier, LSP.Diagnostic[] diagnostics, string resultId);
 
         /// <summary>
-        /// Creates the appropriate LSP type to report unchanged diagnostics.
+        /// Creates the appropriate LSP type to report unchanged diagnostics. Can return <see langword="false"/> to
+        /// indicate nothing should be reported.  This should be done for workspace requests to avoiding sending a huge
+        /// amount of "nothing changed" responses for most files.
         /// </summary>
-        protected abstract TReport CreateUnchangedReport(TextDocumentIdentifier identifier, string resultId);
+        protected abstract bool TryCreateUnchangedReport(TextDocumentIdentifier identifier, string resultId, [NotNullWhen(true)] out TReport? report);
 
         /// <summary>
         /// Creates the appropriate LSP type to report a removed file.
@@ -193,11 +192,9 @@ await ComputeAndReportCurrentDiagnosticsAsync(
                     //
                     // Note: if this is a workspace request, we can do nothing, as that will be interpreted by the
                     // client as nothing having been changed for that document.
-                    if (!this.IsWorkspacePullDiagnosticsHandler)
-                    {
-                        var previousParams = documentToPreviousDiagnosticParams[diagnosticSource.GetId()];
-                        progress.Report(CreateUnchangedReport(previousParams.TextDocument, previousParams.PreviousResultId));
-                    }
+                    var previousParams = documentToPreviousDiagnosticParams[diagnosticSource.GetId()];
+                    if (TryCreateUnchangedReport(previousParams.TextDocument, previousParams.PreviousResultId, out var report))
+                        progress.Report(report);
                 }
             }
 
diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs
index 70b041533b350..d39af98d94d7b 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs
@@ -34,8 +34,6 @@ internal abstract class AbstractWorkspacePullDiagnosticsHandler<TDiagnosticsPara
     /// </summary>
     private int _lspChanged = 0;
 
-    protected sealed override bool IsWorkspacePullDiagnosticsHandler => true;
-
     protected AbstractWorkspacePullDiagnosticsHandler(
         LspWorkspaceManager workspaceManager,
         LspWorkspaceRegistrationService registrationService,
diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/DocumentPullDiagnosticHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/DocumentPullDiagnosticHandler.cs
index 3942f3a1d2b3e..e9559f60a0123 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/DocumentPullDiagnosticHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/DocumentPullDiagnosticHandler.cs
@@ -49,8 +49,11 @@ protected override VSInternalDiagnosticReport[] CreateReport(TextDocumentIdentif
         protected override VSInternalDiagnosticReport[] CreateRemovedReport(TextDocumentIdentifier identifier)
             => CreateReport(identifier, diagnostics: null, resultId: null);
 
-        protected override VSInternalDiagnosticReport[] CreateUnchangedReport(TextDocumentIdentifier identifier, string resultId)
-            => CreateReport(identifier, diagnostics: null, resultId);
+        protected override bool TryCreateUnchangedReport(TextDocumentIdentifier identifier, string resultId, out VSInternalDiagnosticReport[] report)
+        {
+            report = CreateReport(identifier, diagnostics: null, resultId);
+            return true;
+        }
 
         protected override ImmutableArray<PreviousPullResult>? GetPreviousResults(VSInternalDocumentDiagnosticsParams diagnosticsParams)
         {
diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentPullDiagnosticsHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentPullDiagnosticsHandler.cs
index f6f9086d76436..3a22a8a8ce483 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentPullDiagnosticsHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentPullDiagnosticsHandler.cs
@@ -66,11 +66,14 @@ protected override DocumentDiagnosticPartialReport CreateRemovedReport(TextDocum
             Items = [],
         });
 
-    protected override DocumentDiagnosticPartialReport CreateUnchangedReport(TextDocumentIdentifier identifier, string resultId)
-        => new(new RelatedUnchangedDocumentDiagnosticReport
+    protected override bool TryCreateUnchangedReport(TextDocumentIdentifier identifier, string resultId, out DocumentDiagnosticPartialReport report)
+    {
+        report = new RelatedUnchangedDocumentDiagnosticReport
         {
             ResultId = resultId
-        });
+        };
+        return true;
+    }
 
     protected override DocumentDiagnosticReport? CreateReturn(BufferedProgress<DocumentDiagnosticPartialReport> progress)
     {
diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicWorkspacePullDiagnosticsHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicWorkspacePullDiagnosticsHandler.cs
index bf8905d91fbb3..6c2beb5517041 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicWorkspacePullDiagnosticsHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicWorkspacePullDiagnosticsHandler.cs
@@ -70,20 +70,13 @@ protected override WorkspaceDiagnosticPartialReport CreateRemovedReport(TextDocu
             ]
         });
 
-    protected override WorkspaceDiagnosticPartialReport CreateUnchangedReport(TextDocumentIdentifier identifier, string resultId)
-        => new(new WorkspaceDiagnosticReport
-        {
-            Items =
-            [
-                new WorkspaceUnchangedDocumentDiagnosticReport
-                {
-                    Uri = identifier.Uri,
-                    // The documents provided by workspace reports are never open, so we return null.
-                    Version = null,
-                    ResultId = resultId,
-                }
-            ]
-        });
+    protected override bool TryCreateUnchangedReport(TextDocumentIdentifier identifier, string resultId, out WorkspaceDiagnosticPartialReport report)
+    {
+        // Skip reporting 'unchanged' document reports for workspace pull diagnostics.  There are often a ton of
+        // these and we can save a lot of memory not serializing/deserializing all of this.
+        report = default;
+        return false;
+    }
 
     protected override WorkspaceDiagnosticReport? CreateReturn(BufferedProgress<WorkspaceDiagnosticPartialReport> progress)
     {
diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/WorkspacePullDiagnosticHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/WorkspacePullDiagnosticHandler.cs
index f519b0a632cbd..bb8dc13086045 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/WorkspacePullDiagnosticHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/WorkspacePullDiagnosticHandler.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
@@ -40,8 +41,13 @@ protected override VSInternalWorkspaceDiagnosticReport[] CreateReport(TextDocume
         protected override VSInternalWorkspaceDiagnosticReport[] CreateRemovedReport(TextDocumentIdentifier identifier)
             => CreateReport(identifier, diagnostics: null, resultId: null);
 
-        protected override VSInternalWorkspaceDiagnosticReport[] CreateUnchangedReport(TextDocumentIdentifier identifier, string resultId)
-            => CreateReport(identifier, diagnostics: null, resultId);
+        protected override bool TryCreateUnchangedReport(TextDocumentIdentifier identifier, string resultId, [NotNullWhen(true)] out VSInternalWorkspaceDiagnosticReport[]? report)
+        {
+            // Skip reporting 'unchanged' document reports for workspace pull diagnostics.  There are often a ton of
+            // these and we can save a lot of memory not serializing/deserializing all of this.
+            report = null;
+            return false;
+        }
 
         protected override ImmutableArray<PreviousPullResult>? GetPreviousResults(VSInternalWorkspaceDiagnosticsParams diagnosticsParams)
             => diagnosticsParams.PreviousResults?.Where(d => d.PreviousResultId != null).Select(d => new PreviousPullResult(d.PreviousResultId!, d.TextDocument!)).ToImmutableArray();

From ed4c468751b7a262bf21af29c74ba7d45aecca67 Mon Sep 17 00:00:00 2001
From: David Barbet <dabarbet@microsoft.com>
Date: Wed, 13 Mar 2024 12:26:46 -0700
Subject: [PATCH 065/170] Always log processId and increase attach timeout

---
 .../Microsoft.CodeAnalysis.LanguageServer/Program.cs          | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
index ef7e08dc3842b..4a234a66ed469 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs
@@ -57,6 +57,7 @@ static async Task RunAsync(ServerConfiguration serverConfiguration, Cancellation
 
     var logger = loggerFactory.CreateLogger<Program>();
 
+    logger.Log(serverConfiguration.LaunchDebugger ? LogLevel.Critical : LogLevel.Trace, "Server started with process ID {processId}", Environment.ProcessId);
     if (serverConfiguration.LaunchDebugger)
     {
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
@@ -66,8 +67,7 @@ static async Task RunAsync(ServerConfiguration serverConfiguration, Cancellation
         }
         else
         {
-            var timeout = TimeSpan.FromMinutes(1);
-            logger.LogCritical($"Server started with process ID {Environment.ProcessId}");
+            var timeout = TimeSpan.FromMinutes(2);
             logger.LogCritical($"Waiting {timeout:g} for a debugger to attach");
             using var timeoutSource = new CancellationTokenSource(timeout);
             while (!Debugger.IsAttached && !timeoutSource.Token.IsCancellationRequested)

From 48a38ef63643a920d176572b28557035ca656723 Mon Sep 17 00:00:00 2001
From: sdelarosbil <sdelarosbil@spiria.com>
Date: Wed, 13 Mar 2024 16:29:24 -0400
Subject: [PATCH 066/170] Address code review

---
 ...mentationCommentCompletionProviderTests.cs | 17 +++++++++++
 ...arpCompletionCommandHandlerTests_XmlDoc.vb | 30 ++++++++++++++++---
 ...sicCompletionCommandHandlerTests_XmlDoc.vb | 23 ++++++++++++++
 .../XmlDocCommentCompletionProvider.vb        | 12 ++++----
 4 files changed, 73 insertions(+), 9 deletions(-)

diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
index 09c7f1c4cc4dd..94ca88f585996 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/XmlDocumentationCommentCompletionProviderTests.cs
@@ -1044,6 +1044,23 @@ void Goo() { }
             await VerifyItemExistsAsync(text, "langword");
         }
 
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/11489")]
+        public async Task AttributeValueOnQuote()
+        {
+            var text = """
+                class C
+                {
+                    /// <summary>
+                    /// <see langword="$$
+                    /// </summary>
+                    static void Goo()
+                    {
+                    }
+                }
+                """;
+            await VerifyItemExistsAsync(text, "await", usePreviousCharAsTrigger: true);
+        }
+
         [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/757")]
         public async Task TermAndDescriptionInsideItem()
         {
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_XmlDoc.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_XmlDoc.vb
index 0516b2c762a78..ed69904f96831 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_XmlDoc.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_XmlDoc.vb
@@ -626,8 +626,31 @@ class c
         End Function
 
         <WpfTheory, CombinatorialData>
-        Public Async Function InvokeWithOpenAngleSeeCommitLangwordWithEqualsQuotes(showCompletionInArgumentLists As Boolean) As Task
+        Public Async Function InvokeWithOpenAngleSeeCommitSeeWithEqualsQuotes(showCompletionInArgumentLists As Boolean) As Task
+            Using state = TestStateFactory.CreateCSharpTestState(
+                <Document><![CDATA[
+class c
+{
+    /// <summary>
+    /// <see $$=""
+    /// </summary>
+    void goo() { }
+}
+            ]]></Document>, showCompletionInArgumentLists:=showCompletionInArgumentLists)
 
+                state.SendInvokeCompletionList()
+                state.AssertItemsInOrder({"!--", "![CDATA[", "inheritdoc", "see", "seealso"})
+                state.SendTypeChars("see")
+                Await state.AssertSelectedCompletionItem(displayText:="see")
+                state.SendReturn()
+
+                ' /// <see <see cref=""/$$>=""
+                Await state.AssertLineTextAroundCaret("    /// <see <see cref=""""/", ">=""""")
+            End Using
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        Public Async Function InvokeWithOpenAngleSeeCommitLangwordWithEqualsQuotes(showCompletionInArgumentLists As Boolean) As Task
             Using state = TestStateFactory.CreateCSharpTestState(
                 <Document><![CDATA[
 class c
@@ -644,14 +667,13 @@ class c
                 Await state.AssertSelectedCompletionItem(displayText:="langword")
                 state.SendReturn()
 
-                ' /// <see langword="$$"/>
+                ' /// <see langword="$$"
                 Await state.AssertLineTextAroundCaret("    /// <see langword=""", """")
             End Using
         End Function
 
         <WpfTheory, CombinatorialData>
         Public Async Function InvokeWithOpenAngleSeeCommitLangwordWithSpaceEqualsQuotes(showCompletionInArgumentLists As Boolean) As Task
-
             Using state = TestStateFactory.CreateCSharpTestState(
                 <Document><![CDATA[
 class c
@@ -668,7 +690,7 @@ class c
                 Await state.AssertSelectedCompletionItem(displayText:="langword")
                 state.SendReturn()
 
-                ' /// <see langword="$$"/>
+                ' /// <see langword="$$" =""
                 Await state.AssertLineTextAroundCaret("    /// <see langword=""", """ =""""")
             End Using
         End Function
diff --git a/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_XmlDoc.vb b/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_XmlDoc.vb
index 5345017c14249..ea5b97d706b47 100644
--- a/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_XmlDoc.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/VisualBasicCompletionCommandHandlerTests_XmlDoc.vb
@@ -549,6 +549,29 @@ End Class
             End Using
         End Function
 
+        <WpfFact>
+        Public Async Function InvokeWithOpenAngleSeeCommitSeeWithEqualsQuotes() As Task
+            Using state = TestStateFactory.CreateVisualBasicTestState(
+                <Document><![CDATA[
+Class C
+    ''' <summary>
+    ''' <see $$=""
+    ''' </summary>
+    Sub Goo()
+    End Sub
+End Class
+            ]]></Document>)
+
+                state.SendTypeChars("l")
+                Await state.AssertCompletionSession()
+                Await state.AssertSelectedCompletionItem(displayText:="langword")
+                state.SendReturn()
+
+                ' ''' <see langword="$$"
+                Await state.AssertLineTextAroundCaret("    ''' <see langword=""", """")
+            End Using
+        End Function
+
         <WpfFact>
         Public Async Function InvokeWithOpenAngleCommitSeeOnCloseAngle() As Task
 
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
index 3f81d4ed53984..2d13001e61eff 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
@@ -237,20 +237,20 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
 
                 If targetToken.IsChildToken(Function(n As XmlNameSyntax) n.LocalName) AndAlso targetToken.Parent Is tagNameSyntax Then
                     ' <exception |
-                    items.AddRange(GetAttributes(tagName, tagAttributes))
+                    items.AddRange(GetAttributes(token, tagName, tagAttributes))
                 End If
 
                 '<exception a|
                 If targetToken.IsChildToken(Function(n As XmlNameSyntax) n.LocalName) AndAlso targetToken.Parent.IsParentKind(SyntaxKind.XmlAttribute) Then
                     ' <exception |
-                    items.AddRange(GetAttributes(tagName, tagAttributes))
+                    items.AddRange(GetAttributes(token, tagName, tagAttributes))
                 End If
 
                 '<exception a=""|
                 If (targetToken.IsChildToken(Function(s As XmlStringSyntax) s.EndQuoteToken) AndAlso targetToken.Parent.IsParentKind(SyntaxKind.XmlAttribute)) OrElse
                     targetToken.IsChildToken(Function(a As XmlNameAttributeSyntax) a.EndQuoteToken) OrElse
                     targetToken.IsChildToken(Function(a As XmlCrefAttributeSyntax) a.EndQuoteToken) Then
-                    items.AddRange(GetAttributes(tagName, tagAttributes))
+                    items.AddRange(GetAttributes(token, tagName, tagAttributes))
                 End If
 
                 ' <param name="|"
@@ -330,9 +330,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
             Return TryCast(attribute, XmlNameAttributeSyntax)?.Reference?.Identifier.ValueText
         End Function
 
-        Private Function GetAttributes(tagName As String, attributes As SyntaxList(Of XmlNodeSyntax)) As IEnumerable(Of CompletionItem)
+        Private Function GetAttributes(token As SyntaxToken, tagName As String, attributes As SyntaxList(Of XmlNodeSyntax)) As IEnumerable(Of CompletionItem)
             Dim existingAttributeNames = attributes.Select(AddressOf GetAttributeName).WhereNotNull().ToSet()
-            Return GetAttributeItems(tagName, existingAttributeNames, addEqualsAndQuotes := false)
+            Dim nextToken = token.GetNextToken()
+            Return GetAttributeItems(tagName, existingAttributeNames,
+                                     addEqualsAndQuotes := Not nextToken.IsKind(SyntaxKind.EqualsToken) Or nextToken.HasLeadingTrivia)
         End Function
 
         Private Shared Function GetAttributeName(node As XmlNodeSyntax) As String

From b19afd0d6ef7f492f613d41c40eed4ed05b9db2f Mon Sep 17 00:00:00 2001
From: sdelarosbil <sdelarosbil@spiria.com>
Date: Wed, 13 Mar 2024 17:04:43 -0400
Subject: [PATCH 067/170] Fix formatting

---
 .../CompletionProviders/XmlDocCommentCompletionProvider.vb     | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
index 2d13001e61eff..ce0bc1a06f973 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
@@ -333,8 +333,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
         Private Function GetAttributes(token As SyntaxToken, tagName As String, attributes As SyntaxList(Of XmlNodeSyntax)) As IEnumerable(Of CompletionItem)
             Dim existingAttributeNames = attributes.Select(AddressOf GetAttributeName).WhereNotNull().ToSet()
             Dim nextToken = token.GetNextToken()
-            Return GetAttributeItems(tagName, existingAttributeNames,
-                                     addEqualsAndQuotes := Not nextToken.IsKind(SyntaxKind.EqualsToken) Or nextToken.HasLeadingTrivia)
+            Return GetAttributeItems(tagName, existingAttributeNames, addEqualsAndQuotes := Not nextToken.IsKind(SyntaxKind.EqualsToken) Or nextToken.HasLeadingTrivia)
         End Function
 
         Private Shared Function GetAttributeName(node As XmlNodeSyntax) As String

From a0936644bfa98524f68966020415111239175008 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?=
 <tmat@users.noreply.github.com>
Date: Wed, 13 Mar 2024 15:15:20 -0600
Subject: [PATCH 068/170] Microsoft.VisualStudio.SDK (#72359)

---
 eng/Directory.Packages.props    | 42 ++++++++++++++++-----------------
 eng/generate-vssdk-versions.csx | 25 ++++++++++++++++----
 2 files changed, 41 insertions(+), 26 deletions(-)

diff --git a/eng/Directory.Packages.props b/eng/Directory.Packages.props
index 7c204fad33abc..44f9452dad04e 100644
--- a/eng/Directory.Packages.props
+++ b/eng/Directory.Packages.props
@@ -21,7 +21,7 @@
     <MicrosoftWindowsDesktopAppRuntimePackagesVersion>8.0.0</MicrosoftWindowsDesktopAppRuntimePackagesVersion>
     <xunitVersion>2.4.1</xunitVersion>
     <SqliteVersion>2.1.0</SqliteVersion>
-    <MicrosoftVisualStudioExtensibilityVersion>17.9.43-preview-1</MicrosoftVisualStudioExtensibilityVersion>
+    <MicrosoftVisualStudioExtensibilityVersion>17.10.22-preview-1</MicrosoftVisualStudioExtensibilityVersion>
   </PropertyGroup>
 
   <!--
@@ -54,7 +54,7 @@
     <!--
       Visual Studio
     -->
-    <PackageVersion Include="Microsoft.VisualStudio.SDK" Version="17.9.35796-preview.1" />
+    <PackageVersion Include="Microsoft.VisualStudio.SDK" Version="17.10.234-preview.1" />
     <PackageVersion Include="Microsoft.Internal.VisualStudio.Shell.Framework" Version="17.9.35796-preview.1" />
     <PackageVersion Include="Microsoft.ServiceHub.Client" Version="4.2.1017" />
     <PackageVersion Include="Microsoft.VisualStudio.Extensibility" Version="$(MicrosoftVisualStudioExtensibilityVersion)" />
@@ -88,34 +88,32 @@
     <!--
       Subset of Microsoft.VisualStudio.Sdk meta-package (run `csi generate-vssdk-versions.csx` to update based on VSSDK meta-package).
     -->
-    <PackageVersion Include="Microsoft.VisualStudio.Composition" Version="17.10.11-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.CoreUtility" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Editor" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.ImageCatalog" Version="17.10.639-preview.1" />
-    <PackageVersion Include="Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime" Version="17.10.616-preview.1" />
-    <PackageVersion Include="Microsoft.VisualStudio.Language.NavigateTo.Interfaces" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.LanguageServer.Client" Version="17.9.25-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Language.StandardClassification" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Language" Version="17.9.80-preview" />
+    <PackageVersion Include="Microsoft.ServiceHub.Framework" Version="4.4.22" />
+    <PackageVersion Include="Microsoft.VisualStudio.Composition" Version="17.10.8-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Composition.Analyzers" Version="17.10.8-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.CoreUtility" Version="17.10.13-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Editor" Version="17.10.13-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.ImageCatalog" Version="17.10.234-preview.1" />
+    <PackageVersion Include="Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime" Version="17.10.157-preview.1" />
+    <PackageVersion Include="Microsoft.VisualStudio.Language" Version="17.10.13-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Language.NavigateTo.Interfaces" Version="17.10.13-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Language.StandardClassification" Version="17.10.13-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.LanguageServer.Client" Version="17.10.11-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.RemoteControl" Version="16.3.52" />
     <PackageVersion Include="Microsoft.VisualStudio.RpcContracts" Version="17.10.3-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Shell.15.0" Version="17.10.639-preview.1" />
-    <PackageVersion Include="Microsoft.VisualStudio.Telemetry" Version="17.10.4" />
-    <PackageVersion Include="Microsoft.VisualStudio.Text.Data" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Text.Logic" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Text.UI" Version="17.9.80-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Text.UI.Wpf" Version="17.9.80-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Shell.15.0" Version="17.10.234-preview.1" />
+    <PackageVersion Include="Microsoft.VisualStudio.Telemetry" Version="17.9.102" />
+    <PackageVersion Include="Microsoft.VisualStudio.Text.Data" Version="17.10.13-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Text.Logic" Version="17.10.13-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Text.UI" Version="17.10.13-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Text.UI.Wpf" Version="17.10.13-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Threading" Version="17.10.12-preview" />
+    <PackageVersion Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.10.12-preview" />
     <PackageVersion Include="Microsoft.VisualStudio.Utilities.Internal" Version="16.3.56" />
     <PackageVersion Include="Nerdbank.Streams" Version="2.10.69" />
     <PackageVersion Include="Newtonsoft.Json" Version="$(NewtonsoftJsonVersion)" />
     <PackageVersion Include="StreamJsonRpc" Version="2.18.6-preview" />
 
-    <!-- TODO: workaround for https://github.com/dotnet/roslyn/issues/71377 -->
-    <PackageVersion Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.10.12-preview" />
-    <PackageVersion Include="Microsoft.VisualStudio.Composition.Analyzers" Version="17.10.11-preview" />
-    <PackageVersion Include="Microsoft.ServiceHub.Framework" Version="4.4.22"/>
-
     <!--
       VS Debugger
     -->
diff --git a/eng/generate-vssdk-versions.csx b/eng/generate-vssdk-versions.csx
index ceacfcaa4fd8f..00418d83313e0 100644
--- a/eng/generate-vssdk-versions.csx
+++ b/eng/generate-vssdk-versions.csx
@@ -30,7 +30,7 @@ if (!File.Exists(vssdkPackageSpecPath))
 
 var vssdkPackageSpec = XDocument.Parse(File.ReadAllText(vssdkPackageSpecPath));
 
-var properties = new List<string>();
+var properties = new List<(string packageId, string version)>();
 
 foreach (var node in vssdkPackageSpec.Descendants())
 {
@@ -44,6 +44,7 @@ foreach (var node in vssdkPackageSpec.Descendants())
 
         if (!id.StartsWith("Microsoft.VisualStudio") &&
             !id.StartsWith("Microsoft.ServiceHub") &&
+            !id.StartsWith("Microsoft.Build") &&
             id != "Newtonsoft.Json" &&
             id != "StreamJsonRpc" &&
             id != "Nerdbank.Streams")
@@ -56,15 +57,31 @@ foreach (var node in vssdkPackageSpec.Descendants())
             continue;
         }
 
-        properties.Add($"<PackageVersion Include=\"{id}\" Version=\"{version}\" />");
+        properties.Add((id, version));
     }
 }
 
 properties.Sort();
 
-foreach (var property in properties)
+var seenMsbuild = false;
+foreach (var (id, version) in properties)
 {
-    Console.WriteLine(property);
+    if (!id.StartsWith("Microsoft.Build"))
+    {
+        Console.WriteLine($"<PackageVersion Include=\"{id}\" Version=\"{version}\" />");
+    }
+    else if (!seenMsbuild)
+    {
+        Console.WriteLine($$"""
+            <ItemGroup Condition="'$(DotnetBuildFromSource)' != 'true' and '$(TargetFramework)' == 'net472'">
+              <PackageVersion Include="Microsoft.Build" Version="{{version}}" />
+              <PackageVersion Include="Microsoft.Build.Framework" Version="{{version}}" />
+              <PackageVersion Include="Microsoft.Build.Tasks.Core" Version="{{version}}" />
+            </ItemGroup>
+            """);
+
+        seenMsbuild = true;
+    }
 }
 
 return 0;

From 10a82d0f232e572f713ee06b820542c2ec918009 Mon Sep 17 00:00:00 2001
From: sdelarosbil <sdelarosbil@spiria.com>
Date: Wed, 13 Mar 2024 17:35:31 -0400
Subject: [PATCH 069/170] Fix formatting

---
 .../CompletionProviders/XmlDocCommentCompletionProvider.vb     | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
index ce0bc1a06f973..220fea7817f55 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/XmlDocCommentCompletionProvider.vb
@@ -333,7 +333,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
         Private Function GetAttributes(token As SyntaxToken, tagName As String, attributes As SyntaxList(Of XmlNodeSyntax)) As IEnumerable(Of CompletionItem)
             Dim existingAttributeNames = attributes.Select(AddressOf GetAttributeName).WhereNotNull().ToSet()
             Dim nextToken = token.GetNextToken()
-            Return GetAttributeItems(tagName, existingAttributeNames, addEqualsAndQuotes := Not nextToken.IsKind(SyntaxKind.EqualsToken) Or nextToken.HasLeadingTrivia)
+            Return GetAttributeItems(tagName, existingAttributeNames,
+                                     addEqualsAndQuotes:=Not nextToken.IsKind(SyntaxKind.EqualsToken) Or nextToken.HasLeadingTrivia)
         End Function
 
         Private Shared Function GetAttributeName(node As XmlNodeSyntax) As String

From f087922266f56cd8805602c099773e8b8e86ddde Mon Sep 17 00:00:00 2001
From: Matt Mitchell <mmitche@microsoft.com>
Date: Wed, 13 Mar 2024 16:00:05 -0700
Subject: [PATCH 070/170] Exclude VS-related packages on non-Windows (#72470)

* Conditionalize setup packages to build only on Windows
Set static graph restore to true on non-windows to align with windows scripting.

* Fix EOL

* Nothing hard is ever easy
---
 eng/build.sh                    | 4 ++++
 src/Setup/Directory.Build.props | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/eng/build.sh b/eng/build.sh
index 976487bc9db3c..44a7f987d853a 100755
--- a/eng/build.sh
+++ b/eng/build.sh
@@ -78,6 +78,7 @@ prepare_machine=false
 warn_as_error=false
 properties=""
 source_build=false
+restoreUseStaticGraphEvaluation=true
 solution_to_build="Compilers.slnf"
 
 args=""
@@ -172,6 +173,8 @@ while [[ $# > 0 ]]; do
       # Arcade specifies /p:ArcadeBuildFromSource=true instead of --sourceBuild, but that's not developer friendly so we
       # have an alias.
       source_build=true
+      # RestoreUseStaticGraphEvaluation will cause prebuilts
+      restoreUseStaticGraphEvaluation=false
       ;;
     --solution)
       solution_to_build=$2
@@ -294,6 +297,7 @@ function BuildSolution {
     /p:Pack=$pack \
     /p:Publish=$publish \
     /p:RunAnalyzersDuringBuild=$run_analyzers \
+    /p:RestoreUseStaticGraphEvaluation=$restoreUseStaticGraphEvaluation \
     /p:BootstrapBuildPath="$bootstrap_dir" \
     /p:ContinuousIntegrationBuild=$ci \
     /p:TreatWarningsAsErrors=true \
diff --git a/src/Setup/Directory.Build.props b/src/Setup/Directory.Build.props
index 6eef643958f56..50fecf188a03e 100644
--- a/src/Setup/Directory.Build.props
+++ b/src/Setup/Directory.Build.props
@@ -2,5 +2,7 @@
   <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
   <PropertyGroup>
     <ExcludeFromSourceBuild>true</ExcludeFromSourceBuild>
+    <!-- Exclude from building on OS's that don't have VS SDK tooling -->
+    <ExcludeFromBuild Condition="'$(OS)'!= 'Windows_NT'">true</ExcludeFromBuild>
   </PropertyGroup>
 </Project>

From c87268add3728c1bc0e4a1b1fb4ac936934e5ea8 Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Wed, 13 Mar 2024 17:44:38 -0700
Subject: [PATCH 071/170] Remove ImmutableHashMap in favor of
 ImmutableDictionary (#72520)

My understanding is that ImmutableHashMap precedes ImmutableDictionary and only exists because of that reason. These two data structures appear to have similar performance and functionality. There is no reason to have our own implementation if there isn't an advantage to doing so.
---
 .../Portable/Workspace/Solution/Project.cs    |   21 +-
 .../Portable/Workspace/Solution/Solution.cs   |    7 +-
 .../Core/CompilerExtensions.projitems         |    2 -
 .../CompilerUtilities/ImmutableHashMap.cs     | 1120 -----------------
 .../ImmutableHashMapExtensions.cs             |   58 -
 5 files changed, 13 insertions(+), 1195 deletions(-)
 delete mode 100644 src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CompilerUtilities/ImmutableHashMap.cs
 delete mode 100644 src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CompilerUtilities/ImmutableHashMapExtensions.cs

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
index 35c2a92e943b8..1ead6e28e9b29 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Project.cs
@@ -15,7 +15,6 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
-using Roslyn.Collections.Immutable;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis;
@@ -28,10 +27,10 @@ public partial class Project
 {
     private readonly Solution _solution;
     private readonly ProjectState _projectState;
-    private ImmutableHashMap<DocumentId, Document> _idToDocumentMap = [];
-    private ImmutableHashMap<DocumentId, SourceGeneratedDocument> _idToSourceGeneratedDocumentMap = [];
-    private ImmutableHashMap<DocumentId, AdditionalDocument> _idToAdditionalDocumentMap = [];
-    private ImmutableHashMap<DocumentId, AnalyzerConfigDocument> _idToAnalyzerConfigDocumentMap = [];
+    private ImmutableDictionary<DocumentId, Document?> _idToDocumentMap = ImmutableDictionary<DocumentId, Document?>.Empty;
+    private ImmutableDictionary<DocumentId, SourceGeneratedDocument> _idToSourceGeneratedDocumentMap = ImmutableDictionary<DocumentId, SourceGeneratedDocument>.Empty;
+    private ImmutableDictionary<DocumentId, AdditionalDocument?> _idToAdditionalDocumentMap = ImmutableDictionary<DocumentId, AdditionalDocument?>.Empty;
+    private ImmutableDictionary<DocumentId, AnalyzerConfigDocument?> _idToAnalyzerConfigDocumentMap = ImmutableDictionary<DocumentId, AnalyzerConfigDocument?>.Empty;
 
     internal Project(Solution solution, ProjectState projectState)
     {
@@ -236,19 +235,19 @@ public bool ContainsAnalyzerConfigDocument(DocumentId documentId)
     /// Get the document in this project with the specified document Id.
     /// </summary>
     public Document? GetDocument(DocumentId documentId)
-        => ImmutableHashMapExtensions.GetOrAdd(ref _idToDocumentMap, documentId, s_tryCreateDocumentFunction, this);
+        => ImmutableInterlocked.GetOrAdd(ref _idToDocumentMap, documentId, s_tryCreateDocumentFunction, this);
 
     /// <summary>
     /// Get the additional document in this project with the specified document Id.
     /// </summary>
     public TextDocument? GetAdditionalDocument(DocumentId documentId)
-        => ImmutableHashMapExtensions.GetOrAdd(ref _idToAdditionalDocumentMap, documentId, s_tryCreateAdditionalDocumentFunction, this);
+        => ImmutableInterlocked.GetOrAdd(ref _idToAdditionalDocumentMap, documentId, s_tryCreateAdditionalDocumentFunction, this);
 
     /// <summary>
     /// Get the analyzer config document in this project with the specified document Id.
     /// </summary>
     public AnalyzerConfigDocument? GetAnalyzerConfigDocument(DocumentId documentId)
-        => ImmutableHashMapExtensions.GetOrAdd(ref _idToAnalyzerConfigDocumentMap, documentId, s_tryCreateAnalyzerConfigDocumentFunction, this);
+        => ImmutableInterlocked.GetOrAdd(ref _idToAnalyzerConfigDocumentMap, documentId, s_tryCreateAnalyzerConfigDocumentFunction, this);
 
     /// <summary>
     /// Gets a document or a source generated document in this solution with the specified document ID.
@@ -285,7 +284,7 @@ public async ValueTask<IEnumerable<SourceGeneratedDocument>> GetSourceGeneratedD
 
         // return an iterator to avoid eagerly allocating all the document instances
         return generatedDocumentStates.States.Values.Select(state =>
-            ImmutableHashMapExtensions.GetOrAdd(ref _idToSourceGeneratedDocumentMap, state.Id, s_createSourceGeneratedDocumentFunction, (state, this)))!;
+            ImmutableInterlocked.GetOrAdd(ref _idToSourceGeneratedDocumentMap, state.Id, s_createSourceGeneratedDocumentFunction, (state, this)));
     }
 
     internal async ValueTask<IEnumerable<Document>> GetAllRegularAndSourceGeneratedDocumentsAsync(CancellationToken cancellationToken = default)
@@ -318,7 +317,7 @@ internal async ValueTask<IEnumerable<Document>> GetAllRegularAndSourceGeneratedD
     }
 
     internal SourceGeneratedDocument GetOrCreateSourceGeneratedDocument(SourceGeneratedDocumentState state)
-        => ImmutableHashMapExtensions.GetOrAdd(ref _idToSourceGeneratedDocumentMap, state.Id, s_createSourceGeneratedDocumentFunction, (state, this))!;
+        => ImmutableInterlocked.GetOrAdd(ref _idToSourceGeneratedDocumentMap, state.Id, s_createSourceGeneratedDocumentFunction, (state, this));
 
     /// <summary>
     /// Returns the <see cref="SourceGeneratedDocumentState"/> for a source generated document that has already been generated and observed.
@@ -349,7 +348,7 @@ internal SourceGeneratedDocument GetOrCreateSourceGeneratedDocument(SourceGenera
         if (documentState == null)
             return null;
 
-        return ImmutableHashMapExtensions.GetOrAdd(ref _idToSourceGeneratedDocumentMap, documentId, s_createSourceGeneratedDocumentFunction, (documentState, this));
+        return ImmutableInterlocked.GetOrAdd(ref _idToSourceGeneratedDocumentMap, documentId, s_createSourceGeneratedDocumentFunction, (documentState, this));
     }
 
     internal ValueTask<ImmutableArray<Diagnostic>> GetSourceGeneratorDiagnosticsAsync(CancellationToken cancellationToken)
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Solution.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Solution.cs
index e7d1aeca91fcf..cafe4e3d878c3 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Solution.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Solution.cs
@@ -15,7 +15,6 @@
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
-using Roslyn.Collections.Immutable;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis;
@@ -28,7 +27,7 @@ public partial class Solution
     private readonly SolutionCompilationState _compilationState;
 
     // Values for all these are created on demand.
-    private ImmutableHashMap<ProjectId, Project> _projectIdToProjectMap;
+    private ImmutableDictionary<ProjectId, Project> _projectIdToProjectMap;
 
     /// <summary>
     /// Result of calling <see cref="WithFrozenPartialCompilationsAsync"/>.
@@ -45,7 +44,7 @@ private Solution(
         SolutionCompilationState compilationState,
         AsyncLazy<Solution>? cachedFrozenSolution = null)
     {
-        _projectIdToProjectMap = [];
+        _projectIdToProjectMap = ImmutableDictionary<ProjectId, Project>.Empty;
         _compilationState = compilationState;
 
         _cachedFrozenSolution = cachedFrozenSolution ??
@@ -141,7 +140,7 @@ public Workspace Workspace
     {
         if (this.ContainsProject(projectId))
         {
-            return ImmutableHashMapExtensions.GetOrAdd(ref _projectIdToProjectMap, projectId, s_createProjectFunction, this);
+            return ImmutableInterlocked.GetOrAdd(ref _projectIdToProjectMap, projectId, s_createProjectFunction, this);
         }
 
         return null;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
index 320b61bf7b2f4..bbe77051ecf65 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/CompilerExtensions.projitems
@@ -540,8 +540,6 @@
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\TextSpanExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\CompilerUtilities\CompilerPathUtilities.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\CompilerUtilities\ImmutableDictionaryExtensions.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Utilities\CompilerUtilities\ImmutableHashMap.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Utilities\CompilerUtilities\ImmutableHashMapExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ConcatImmutableArray`1.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ReferenceCountedDisposable.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\ReferenceCountedDisposableCache.cs" />
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CompilerUtilities/ImmutableHashMap.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CompilerUtilities/ImmutableHashMap.cs
deleted file mode 100644
index fdc05e011a342..0000000000000
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CompilerUtilities/ImmutableHashMap.cs
+++ /dev/null
@@ -1,1120 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Diagnostics.Contracts;
-using System.Linq;
-using System.Text;
-using Microsoft.CodeAnalysis;
-using Roslyn.Utilities;
-using Contract = System.Diagnostics.Contracts.Contract;
-
-namespace Roslyn.Collections.Immutable;
-
-/// <summary>
-/// An immutable unordered hash map implementation.
-/// </summary>
-/// <typeparam name="TKey">The type of the key.</typeparam>
-/// <typeparam name="TValue">The type of the value.</typeparam>
-[DebuggerDisplay("Count = {Count}")]
-[DebuggerTypeProxy(typeof(ImmutableHashMap<,>.DebuggerProxy))]
-[SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
-internal sealed class ImmutableHashMap<TKey, TValue> : IImmutableDictionary<TKey, TValue>
-    where TKey : notnull
-{
-    private static readonly ImmutableHashMap<TKey, TValue> s_emptySingleton = [];
-
-    /// <summary>
-    /// The root node of the tree that stores this map.
-    /// </summary>
-    private readonly Bucket? _root;
-
-    /// <summary>
-    /// The comparer used to sort keys in this map.
-    /// </summary>
-    private readonly IEqualityComparer<TKey> _keyComparer;
-
-    /// <summary>
-    /// The comparer used to detect equivalent values in this map.
-    /// </summary>
-    private readonly IEqualityComparer<TValue> _valueComparer;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ImmutableHashMap&lt;TKey, TValue&gt;"/> class.
-    /// </summary>
-    /// <param name="root">The root.</param>
-    /// <param name="comparer">The comparer.</param>
-    /// <param name="valueComparer">The value comparer.</param>
-    private ImmutableHashMap(Bucket? root, IEqualityComparer<TKey> comparer, IEqualityComparer<TValue> valueComparer)
-        : this(comparer, valueComparer)
-    {
-        RoslynDebug.AssertNotNull(comparer);
-        RoslynDebug.AssertNotNull(valueComparer);
-
-        _root = root;
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ImmutableHashMap&lt;TKey, TValue&gt;"/> class.
-    /// </summary>
-    /// <param name="comparer">The comparer.</param>
-    /// <param name="valueComparer">The value comparer.</param>
-    internal ImmutableHashMap(IEqualityComparer<TKey>? comparer = null, IEqualityComparer<TValue>? valueComparer = null)
-    {
-        _keyComparer = comparer ?? EqualityComparer<TKey>.Default;
-        _valueComparer = valueComparer ?? EqualityComparer<TValue>.Default;
-    }
-
-    /// <summary>
-    /// Gets an empty map with default equality comparers.
-    /// </summary>
-    public static ImmutableHashMap<TKey, TValue> Empty => s_emptySingleton;
-
-    /// <summary>
-    /// See the <see cref="IImmutableDictionary&lt;TKey, TValue&gt;"/> interface.
-    /// </summary>
-    public ImmutableHashMap<TKey, TValue> Clear()
-        => this.IsEmpty ? this : Empty.WithComparers(_keyComparer, _valueComparer);
-
-    #region Public methods
-
-    /// <summary>
-    /// See the <see cref="IImmutableDictionary&lt;TKey, TValue&gt;"/> interface.
-    /// </summary>
-    [Pure]
-    public ImmutableHashMap<TKey, TValue> Add(TKey key, TValue value)
-    {
-        Requires.NotNullAllowStructs(key, "key");
-        Contract.Ensures(Contract.Result<ImmutableHashMap<TKey, TValue>>() != null);
-        var vb = new ValueBucket(key, value, _keyComparer.GetHashCode(key));
-        if (_root == null)
-        {
-            return this.Wrap(vb);
-        }
-        else
-        {
-            return this.Wrap(_root.Add(0, vb, _keyComparer, _valueComparer, false));
-        }
-    }
-
-    /// <summary>
-    /// See the <see cref="IImmutableDictionary&lt;TKey, TValue&gt;"/> interface.
-    /// </summary>
-    [Pure]
-    public ImmutableHashMap<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs)
-    {
-        Requires.NotNull(pairs, "pairs");
-        Contract.Ensures(Contract.Result<ImmutableHashMap<TKey, TValue>>() != null);
-
-        return this.AddRange(pairs, overwriteOnCollision: false, avoidToHashMap: false);
-    }
-
-    /// <summary>
-    /// See the <see cref="IImmutableDictionary&lt;TKey, TValue&gt;"/> interface.
-    /// </summary>
-    [Pure]
-    public ImmutableHashMap<TKey, TValue> SetItem(TKey key, TValue value)
-    {
-        Requires.NotNullAllowStructs(key, "key");
-        Contract.Ensures(Contract.Result<ImmutableHashMap<TKey, TValue>>() != null);
-        Contract.Ensures(!Contract.Result<ImmutableHashMap<TKey, TValue>>().IsEmpty);
-        var vb = new ValueBucket(key, value, _keyComparer.GetHashCode(key));
-        if (_root == null)
-        {
-            return this.Wrap(vb);
-        }
-        else
-        {
-            return this.Wrap(_root.Add(0, vb, _keyComparer, _valueComparer, true));
-        }
-    }
-
-    /// <summary>
-    /// Applies a given set of key=value pairs to an immutable dictionary, replacing any conflicting keys in the resulting dictionary.
-    /// </summary>
-    /// <param name="items">The key=value pairs to set on the map.  Any keys that conflict with existing keys will overwrite the previous values.</param>
-    /// <returns>An immutable dictionary.</returns>
-    [Pure]
-    public ImmutableHashMap<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
-    {
-        Requires.NotNull(items, "items");
-        Contract.Ensures(Contract.Result<ImmutableDictionary<TKey, TValue>>() != null);
-
-        return this.AddRange(items, overwriteOnCollision: true, avoidToHashMap: false);
-    }
-
-    /// <summary>
-    /// See the <see cref="IImmutableDictionary&lt;TKey, TValue&gt;"/> interface.
-    /// </summary>
-    [Pure]
-    public ImmutableHashMap<TKey, TValue> Remove(TKey key)
-    {
-        Requires.NotNullAllowStructs(key, "key");
-        Contract.Ensures(Contract.Result<ImmutableHashMap<TKey, TValue>>() != null);
-        if (_root != null)
-        {
-            return this.Wrap(_root.Remove(_keyComparer.GetHashCode(key), key, _keyComparer));
-        }
-
-        return this;
-    }
-
-    /// <summary>
-    /// See the <see cref="IImmutableDictionary&lt;TKey, TValue&gt;"/> interface.
-    /// </summary>
-    [Pure]
-    public ImmutableHashMap<TKey, TValue> RemoveRange(IEnumerable<TKey> keys)
-    {
-        Requires.NotNull(keys, "keys");
-        Contract.Ensures(Contract.Result<ImmutableHashMap<TKey, TValue>>() != null);
-        var map = _root;
-        if (map != null)
-        {
-            foreach (var key in keys)
-            {
-                map = map.Remove(_keyComparer.GetHashCode(key), key, _keyComparer);
-                if (map == null)
-                {
-                    break;
-                }
-            }
-        }
-
-        return this.Wrap(map);
-    }
-
-    /// <summary>
-    /// Returns a hash map that uses the specified key and value comparers and has the same contents as this map.
-    /// </summary>
-    /// <param name="keyComparer">The key comparer.  A value of <c>null</c> results in using the default equality comparer for the type.</param>
-    /// <param name="valueComparer">The value comparer.  A value of <c>null</c> results in using the default equality comparer for the type.</param>
-    /// <returns>The hash map with the new comparers.</returns>
-    /// <remarks>
-    /// In the event that a change in the key equality comparer results in a key collision, an exception is thrown.
-    /// </remarks>
-    [Pure]
-    public ImmutableHashMap<TKey, TValue> WithComparers(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
-    {
-        keyComparer ??= EqualityComparer<TKey>.Default;
-
-        valueComparer ??= EqualityComparer<TValue>.Default;
-
-        if (_keyComparer == keyComparer)
-        {
-            if (_valueComparer == valueComparer)
-            {
-                return this;
-            }
-            else
-            {
-                // When the key comparer is the same but the value comparer is different, we don't need a whole new tree
-                // because the structure of the tree does not depend on the value comparer.
-                // We just need a new root node to store the new value comparer.
-                return new ImmutableHashMap<TKey, TValue>(_root, _keyComparer, valueComparer);
-            }
-        }
-        else
-        {
-            var set = new ImmutableHashMap<TKey, TValue>(keyComparer, valueComparer);
-            set = set.AddRange(this, overwriteOnCollision: false, avoidToHashMap: true);
-            return set;
-        }
-    }
-
-    /// <summary>
-    /// Returns a hash map that uses the specified key comparer and current value comparer and has the same contents as this map.
-    /// </summary>
-    /// <param name="keyComparer">The key comparer.  A value of <c>null</c> results in using the default equality comparer for the type.</param>
-    /// <returns>The hash map with the new comparers.</returns>
-    /// <remarks>
-    /// In the event that a change in the key equality comparer results in a key collision, an exception is thrown.
-    /// </remarks>
-    [Pure]
-    public ImmutableHashMap<TKey, TValue> WithComparers(IEqualityComparer<TKey> keyComparer)
-        => this.WithComparers(keyComparer, _valueComparer);
-
-    /// <summary>
-    /// Determines whether the ImmutableSortedMap&lt;TKey,TValue&gt;
-    /// contains an element with the specified value.
-    /// </summary>
-    /// <param name="value">
-    /// The value to locate in the ImmutableSortedMap&lt;TKey,TValue&gt;.
-    /// The value can be null for reference types.
-    /// </param>
-    /// <returns>
-    /// true if the ImmutableSortedMap&lt;TKey,TValue&gt; contains
-    /// an element with the specified value; otherwise, false.
-    /// </returns>
-    [Pure]
-    public bool ContainsValue(TValue value)
-        => this.Values.Contains(value, _valueComparer);
-
-    #endregion
-
-    #region IImmutableDictionary<TKey, TValue> Members
-
-    /// <summary>
-    /// Gets the number of elements in this collection.
-    /// </summary>
-    public int Count
-    {
-        get { return _root != null ? _root.Count : 0; }
-    }
-
-    /// <summary>
-    /// Gets a value indicating whether this instance is empty.
-    /// </summary>
-    /// <value>
-    ///   <c>true</c> if this instance is empty; otherwise, <c>false</c>.
-    /// </value>
-    public bool IsEmpty
-    {
-        get { return this.Count == 0; }
-    }
-
-    /// <summary>
-    /// Gets the keys in the map.
-    /// </summary>
-    public IEnumerable<TKey> Keys
-    {
-        get
-        {
-            if (_root == null)
-            {
-                yield break;
-            }
-
-            var stack = new Stack<IEnumerator<Bucket>>();
-            stack.Push(_root.GetAll().GetEnumerator());
-            while (stack.Count > 0)
-            {
-                var en = stack.Peek();
-                if (en.MoveNext())
-                {
-                    if (en.Current is ValueBucket vb)
-                    {
-                        yield return vb.Key;
-                    }
-                    else
-                    {
-                        stack.Push(en.Current.GetAll().GetEnumerator());
-                    }
-                }
-                else
-                {
-                    stack.Pop();
-                }
-            }
-        }
-    }
-
-    /// <summary>
-    /// Gets the values in the map.
-    /// </summary>
-    public IEnumerable<TValue> Values
-    {
-#pragma warning disable 618
-        get { return this.GetValueBuckets().Select(vb => vb.Value); }
-#pragma warning restore 618
-    }
-
-    /// <summary>
-    /// Gets the <typeparamref name="TValue"/> with the specified key.
-    /// </summary>
-    public TValue this[TKey key]
-    {
-        get
-        {
-            if (this.TryGetValue(key, out var value))
-            {
-                return value;
-            }
-
-            throw new KeyNotFoundException();
-        }
-    }
-
-    /// <summary>
-    /// Determines whether the specified key contains key.
-    /// </summary>
-    /// <param name="key">The key.</param>
-    /// <returns>
-    ///   <c>true</c> if the specified key contains key; otherwise, <c>false</c>.
-    /// </returns>
-    public bool ContainsKey(TKey key)
-    {
-        if (_root != null)
-        {
-            var vb = _root.Get(_keyComparer.GetHashCode(key), key, _keyComparer);
-            return vb != null;
-        }
-
-        return false;
-    }
-
-    /// <summary>
-    /// Determines whether this map contains the specified key-value pair.
-    /// </summary>
-    /// <param name="keyValuePair">The key value pair.</param>
-    /// <returns>
-    ///   <c>true</c> if this map contains the key-value pair; otherwise, <c>false</c>.
-    /// </returns>
-    public bool Contains(KeyValuePair<TKey, TValue> keyValuePair)
-    {
-        if (_root != null)
-        {
-            var vb = _root.Get(_keyComparer.GetHashCode(keyValuePair.Key), keyValuePair.Key, _keyComparer);
-            return vb != null && _valueComparer.Equals(vb.Value, keyValuePair.Value);
-        }
-
-        return false;
-    }
-
-    /// <summary>
-    /// See the <see cref="IImmutableDictionary&lt;TKey, TValue&gt;"/> interface.
-    /// </summary>
-#pragma warning disable CS8767 // Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).
-    public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
-#pragma warning restore CS8767 // Nullability of reference types in type of parameter doesn't match implicitly implemented member (possibly because of nullability attributes).
-    {
-        if (_root != null)
-        {
-            var vb = _root.Get(_keyComparer.GetHashCode(key), key, _keyComparer);
-            if (vb != null)
-            {
-                value = vb.Value;
-                return true;
-            }
-        }
-
-        value = default;
-        return false;
-    }
-
-    /// <summary>
-    /// See the <see cref="IImmutableDictionary&lt;TKey, TValue&gt;"/> interface.
-    /// </summary>
-    public bool TryGetKey(TKey equalKey, out TKey actualKey)
-    {
-        if (_root != null)
-        {
-            var vb = _root.Get(_keyComparer.GetHashCode(equalKey), equalKey, _keyComparer);
-            if (vb != null)
-            {
-                actualKey = vb.Key;
-                return true;
-            }
-        }
-
-        actualKey = equalKey;
-        return false;
-    }
-
-    #endregion
-
-    #region IEnumerable<KeyValuePair<TKey, TValue>> Members
-
-    /// <summary>
-    /// Returns an enumerator that iterates through the collection.
-    /// </summary>
-    /// <returns>
-    /// A <see cref="IEnumerator{T}"/> that can be used to iterate through the collection.
-    /// </returns>
-    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
-        => this.GetValueBuckets().Select(vb => new KeyValuePair<TKey, TValue>(vb.Key, vb.Value)).GetEnumerator();
-
-    #endregion
-
-    #region IEnumerable Members
-
-    IEnumerator IEnumerable.GetEnumerator()
-        => this.GetEnumerator();
-
-    #endregion
-
-    /// <summary>
-    /// Returns a <see cref="System.String" /> that represents this instance.
-    /// </summary>
-    /// <returns>
-    /// A <see cref="System.String" /> that represents this instance.
-    /// </returns>
-    public override string ToString()
-    {
-        var builder = new StringBuilder("ImmutableHashMap[");
-        var needComma = false;
-        foreach (var kv in this)
-        {
-            builder.Append(kv.Key);
-            builder.Append(':');
-            builder.Append(kv.Value);
-            if (needComma)
-            {
-                builder.Append(',');
-            }
-
-            needComma = true;
-        }
-
-        builder.Append(']');
-        return builder.ToString();
-    }
-
-    /// <summary>
-    /// Exchanges a key for the actual key instance found in this map.
-    /// </summary>
-    /// <param name="key">The key to search for.</param>
-    /// <param name="existingKey">Receives the equal key found in the map.</param>
-    /// <returns>A value indicating whether an equal and existing key was found in the map.</returns>
-    internal bool TryExchangeKey(TKey key, [NotNullWhen(true)] out TKey? existingKey)
-    {
-        var vb = _root?.Get(_keyComparer.GetHashCode(key), key, _keyComparer);
-        if (vb != null)
-        {
-            existingKey = vb.Key;
-            return true;
-        }
-        else
-        {
-            existingKey = default;
-            return false;
-        }
-    }
-
-    /// <summary>
-    /// Attempts to discover an <see cref="ImmutableHashMap&lt;TKey, TValue&gt;"/> instance beneath some enumerable sequence
-    /// if one exists.
-    /// </summary>
-    /// <param name="sequence">The sequence that may have come from an immutable map.</param>
-    /// <param name="other">Receives the concrete <see cref="ImmutableHashMap&lt;TKey, TValue&gt;"/> typed value if one can be found.</param>
-    /// <returns><c>true</c> if the cast was successful; <c>false</c> otherwise.</returns>
-    private static bool TryCastToImmutableMap(IEnumerable<KeyValuePair<TKey, TValue>> sequence, [NotNullWhen(true)] out ImmutableHashMap<TKey, TValue>? other)
-    {
-        other = sequence as ImmutableHashMap<TKey, TValue>;
-        if (other != null)
-        {
-            return true;
-        }
-
-        return false;
-    }
-
-    private ImmutableHashMap<TKey, TValue> Wrap(Bucket? root)
-    {
-        if (root == null)
-        {
-            return this.Clear();
-        }
-
-        if (_root != root)
-        {
-            return root.Count == 0 ? this.Clear() : new ImmutableHashMap<TKey, TValue>(root, _keyComparer, _valueComparer);
-        }
-
-        return this;
-    }
-
-    /// <summary>
-    /// Bulk adds entries to the map.
-    /// </summary>
-    /// <param name="pairs">The entries to add.</param>
-    /// <param name="overwriteOnCollision"><c>true</c> to allow the <paramref name="pairs"/> sequence to include duplicate keys and let the last one win; <c>false</c> to throw on collisions.</param>
-    /// <param name="avoidToHashMap"><c>true</c> when being called from ToHashMap to avoid StackOverflow.</param>
-    [Pure]
-    private ImmutableHashMap<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs, bool overwriteOnCollision, bool avoidToHashMap)
-    {
-        RoslynDebug.AssertNotNull(pairs);
-        Contract.Ensures(Contract.Result<ImmutableHashMap<TKey, TValue>>() != null);
-
-        // Some optimizations may apply if we're an empty list.
-        if (this.IsEmpty && !avoidToHashMap)
-        {
-            // If the items being added actually come from an ImmutableHashMap<TKey, TValue>
-            // then there is no value in reconstructing it.
-            if (TryCastToImmutableMap(pairs, out var other))
-            {
-                return other.WithComparers(_keyComparer, _valueComparer);
-            }
-        }
-
-        var map = this;
-        foreach (var pair in pairs)
-        {
-            map = overwriteOnCollision
-                ? map.SetItem(pair.Key, pair.Value)
-                : map.Add(pair.Key, pair.Value);
-        }
-
-        return map;
-    }
-
-    private IEnumerable<ValueBucket> GetValueBuckets()
-    {
-        if (_root == null)
-        {
-            yield break;
-        }
-
-        var stack = new Stack<IEnumerator<Bucket>>();
-        stack.Push(_root.GetAll().GetEnumerator());
-        while (stack.Count > 0)
-        {
-            var en = stack.Peek();
-            if (en.MoveNext())
-            {
-                if (en.Current is ValueBucket vb)
-                {
-                    yield return vb;
-                }
-                else
-                {
-                    stack.Push(en.Current.GetAll().GetEnumerator());
-                }
-            }
-            else
-            {
-                stack.Pop();
-            }
-        }
-    }
-
-    private abstract class Bucket
-    {
-        internal abstract int Count { get; }
-
-        internal abstract Bucket Add(int suggestedHashRoll, ValueBucket bucket, IEqualityComparer<TKey> comparer, IEqualityComparer<TValue> valueComparer, bool overwriteExistingValue);
-        internal abstract Bucket? Remove(int hash, TKey key, IEqualityComparer<TKey> comparer);
-        internal abstract ValueBucket? Get(int hash, TKey key, IEqualityComparer<TKey> comparer);
-        internal abstract IEnumerable<Bucket> GetAll();
-    }
-
-    private abstract class ValueOrListBucket : Bucket
-    {
-        /// <summary>
-        /// The hash for this bucket.
-        /// </summary>
-        internal readonly int Hash;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ImmutableHashMap&lt;TKey, TValue&gt;.ValueOrListBucket"/> class.
-        /// </summary>
-        /// <param name="hash">The hash.</param>
-        protected ValueOrListBucket(int hash)
-            => this.Hash = hash;
-    }
-
-    private sealed class ValueBucket : ValueOrListBucket
-    {
-        internal readonly TKey Key;
-        internal readonly TValue Value;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ImmutableHashMap&lt;TKey, TValue&gt;.ValueBucket"/> class.
-        /// </summary>
-        /// <param name="key">The key.</param>
-        /// <param name="value">The value.</param>
-        /// <param name="hashcode">The hashcode.</param>
-        internal ValueBucket(TKey key, TValue value, int hashcode)
-            : base(hashcode)
-        {
-            this.Key = key;
-            this.Value = value;
-        }
-
-        internal override int Count => 1;
-
-        internal override Bucket Add(int suggestedHashRoll, ValueBucket bucket, IEqualityComparer<TKey> comparer, IEqualityComparer<TValue> valueComparer, bool overwriteExistingValue)
-        {
-            if (this.Hash == bucket.Hash)
-            {
-                if (comparer.Equals(this.Key, bucket.Key))
-                {
-                    // Overwrite of same key.  If the value is the same as well, don't switch out the bucket.
-                    if (valueComparer.Equals(this.Value, bucket.Value))
-                    {
-                        return this;
-                    }
-                    else
-                    {
-                        if (overwriteExistingValue)
-                        {
-                            return bucket;
-                        }
-                        else
-                        {
-                            throw new ArgumentException(Strings.DuplicateKey);
-                        }
-                    }
-                }
-                else
-                {
-                    // two of the same hash will never be happy in a hash bucket
-                    return new ListBucket([this, bucket]);
-                }
-            }
-            else
-            {
-                return new HashBucket(suggestedHashRoll, this, bucket);
-            }
-        }
-
-        internal override Bucket? Remove(int hash, TKey key, IEqualityComparer<TKey> comparer)
-        {
-            if (this.Hash == hash && comparer.Equals(this.Key, key))
-            {
-                return null;
-            }
-
-            return this;
-        }
-
-        internal override ValueBucket? Get(int hash, TKey key, IEqualityComparer<TKey> comparer)
-        {
-            if (this.Hash == hash && comparer.Equals(this.Key, key))
-            {
-                return this;
-            }
-
-            return null;
-        }
-
-        internal override IEnumerable<Bucket> GetAll()
-            => SpecializedCollections.SingletonEnumerable(this);
-    }
-
-    private sealed class ListBucket : ValueOrListBucket
-    {
-        private readonly ValueBucket[] _buckets;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ImmutableHashMap&lt;TKey, TValue&gt;.ListBucket"/> class.
-        /// </summary>
-        /// <param name="buckets">The buckets.</param>
-        internal ListBucket(ValueBucket[] buckets)
-            : base(buckets[0].Hash)
-        {
-            RoslynDebug.AssertNotNull(buckets);
-            Debug.Assert(buckets.Length >= 2);
-            _buckets = buckets;
-        }
-
-        internal override int Count => _buckets.Length;
-
-        internal override Bucket Add(int suggestedHashRoll, ValueBucket bucket, IEqualityComparer<TKey> comparer, IEqualityComparer<TValue> valueComparer, bool overwriteExistingValue)
-        {
-            if (this.Hash == bucket.Hash)
-            {
-                var pos = this.Find(bucket.Key, comparer);
-                if (pos >= 0)
-                {
-                    // If the value hasn't changed for this key, return the original bucket.
-                    if (valueComparer.Equals(bucket.Value, _buckets[pos].Value))
-                    {
-                        return this;
-                    }
-                    else
-                    {
-                        if (overwriteExistingValue)
-                        {
-                            return new ListBucket(_buckets.ReplaceAt(pos, bucket));
-                        }
-                        else
-                        {
-                            throw new ArgumentException(Strings.DuplicateKey);
-                        }
-                    }
-                }
-                else
-                {
-                    return new ListBucket(_buckets.InsertAt(_buckets.Length, bucket));
-                }
-            }
-            else
-            {
-                return new HashBucket(suggestedHashRoll, this, bucket);
-            }
-        }
-
-        internal override Bucket? Remove(int hash, TKey key, IEqualityComparer<TKey> comparer)
-        {
-            if (this.Hash == hash)
-            {
-                var pos = this.Find(key, comparer);
-                if (pos >= 0)
-                {
-                    if (_buckets.Length == 1)
-                    {
-                        return null;
-                    }
-                    else if (_buckets.Length == 2)
-                    {
-                        return pos == 0 ? _buckets[1] : _buckets[0];
-                    }
-                    else
-                    {
-                        return new ListBucket(_buckets.RemoveAt(pos));
-                    }
-                }
-            }
-
-            return this;
-        }
-
-        internal override ValueBucket? Get(int hash, TKey key, IEqualityComparer<TKey> comparer)
-        {
-            if (this.Hash == hash)
-            {
-                var pos = this.Find(key, comparer);
-                if (pos >= 0)
-                {
-                    return _buckets[pos];
-                }
-            }
-
-            return null;
-        }
-
-        private int Find(TKey key, IEqualityComparer<TKey> comparer)
-        {
-            for (var i = 0; i < _buckets.Length; i++)
-            {
-                if (comparer.Equals(key, _buckets[i].Key))
-                {
-                    return i;
-                }
-            }
-
-            return -1;
-        }
-
-        internal override IEnumerable<Bucket> GetAll()
-            => _buckets;
-    }
-
-    private sealed class HashBucket : Bucket
-    {
-        private readonly int _hashRoll;
-        private readonly uint _used;
-        private readonly Bucket[] _buckets;
-        private readonly int _count;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ImmutableHashMap&lt;TKey, TValue&gt;.HashBucket"/> class.
-        /// </summary>
-        /// <param name="hashRoll">The hash roll.</param>
-        /// <param name="used">The used.</param>
-        /// <param name="buckets">The buckets.</param>
-        /// <param name="count">The count.</param>
-        private HashBucket(int hashRoll, uint used, Bucket[] buckets, int count)
-        {
-            RoslynDebug.AssertNotNull(buckets);
-            Debug.Assert(buckets.Length == CountBits(used));
-
-            _hashRoll = hashRoll & 31;
-            _used = used;
-            _buckets = buckets;
-            _count = count;
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="ImmutableHashMap&lt;TKey, TValue&gt;.HashBucket"/> class.
-        /// </summary>
-        /// <param name="suggestedHashRoll">The suggested hash roll.</param>
-        /// <param name="bucket1">The bucket1.</param>
-        /// <param name="bucket2">The bucket2.</param>
-        internal HashBucket(int suggestedHashRoll, ValueOrListBucket bucket1, ValueOrListBucket bucket2)
-        {
-            RoslynDebug.AssertNotNull(bucket1);
-            RoslynDebug.AssertNotNull(bucket2);
-            Debug.Assert(bucket1.Hash != bucket2.Hash);
-
-            // find next hashRoll that causes these two to be slotted in different buckets
-            var h1 = bucket1.Hash;
-            var h2 = bucket2.Hash;
-            int s1;
-            int s2;
-            for (var i = 0; i < 32; i++)
-            {
-                _hashRoll = (suggestedHashRoll + i) & 31;
-                s1 = this.ComputeLogicalSlot(h1);
-                s2 = this.ComputeLogicalSlot(h2);
-                if (s1 != s2)
-                {
-                    _count = 2;
-                    _used = (1u << s1) | (1u << s2);
-                    _buckets = new Bucket[2];
-                    _buckets[this.ComputePhysicalSlot(s1)] = bucket1;
-                    _buckets[this.ComputePhysicalSlot(s2)] = bucket2;
-                    return;
-                }
-            }
-
-            throw new InvalidOperationException();
-        }
-
-        internal override int Count => _count;
-
-        internal override Bucket Add(int suggestedHashRoll, ValueBucket bucket, IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, bool overwriteExistingValue)
-        {
-            var logicalSlot = ComputeLogicalSlot(bucket.Hash);
-            if (IsInUse(logicalSlot))
-            {
-                // if this slot is in use, then add the new item to the one in this slot
-                var physicalSlot = ComputePhysicalSlot(logicalSlot);
-                var existing = _buckets[physicalSlot];
-
-                // suggest hash roll that will cause any nested hash bucket to use entirely new bits for picking logical slot
-                // note: we ignore passed in suggestion, and base new suggestion off current hash roll.
-                var added = existing.Add(_hashRoll + 5, bucket, keyComparer, valueComparer, overwriteExistingValue);
-                if (added != existing)
-                {
-                    var newBuckets = _buckets.ReplaceAt(physicalSlot, added);
-                    return new HashBucket(_hashRoll, _used, newBuckets, _count - existing.Count + added.Count);
-                }
-                else
-                {
-                    return this;
-                }
-            }
-            else
-            {
-                var physicalSlot = ComputePhysicalSlot(logicalSlot);
-                var newBuckets = _buckets.InsertAt(physicalSlot, bucket);
-                var newUsed = InsertBit(logicalSlot, _used);
-                return new HashBucket(_hashRoll, newUsed, newBuckets, _count + bucket.Count);
-            }
-        }
-
-        internal override Bucket? Remove(int hash, TKey key, IEqualityComparer<TKey> comparer)
-        {
-            var logicalSlot = ComputeLogicalSlot(hash);
-            if (IsInUse(logicalSlot))
-            {
-                var physicalSlot = ComputePhysicalSlot(logicalSlot);
-                var existing = _buckets[physicalSlot];
-                var result = existing.Remove(hash, key, comparer);
-                if (result == null)
-                {
-                    if (_buckets.Length == 1)
-                    {
-                        return null;
-                    }
-                    else if (_buckets.Length == 2)
-                    {
-                        return physicalSlot == 0 ? _buckets[1] : _buckets[0];
-                    }
-                    else
-                    {
-                        return new HashBucket(_hashRoll, RemoveBit(logicalSlot, _used), _buckets.RemoveAt(physicalSlot), _count - existing.Count);
-                    }
-                }
-                else if (_buckets[physicalSlot] != result)
-                {
-                    return new HashBucket(_hashRoll, _used, _buckets.ReplaceAt(physicalSlot, result), _count - existing.Count + result.Count);
-                }
-            }
-
-            return this;
-        }
-
-        internal override ValueBucket? Get(int hash, TKey key, IEqualityComparer<TKey> comparer)
-        {
-            var logicalSlot = ComputeLogicalSlot(hash);
-            if (IsInUse(logicalSlot))
-            {
-                var physicalSlot = ComputePhysicalSlot(logicalSlot);
-                return _buckets[physicalSlot].Get(hash, key, comparer);
-            }
-
-            return null;
-        }
-
-        internal override IEnumerable<Bucket> GetAll()
-            => _buckets;
-
-        private bool IsInUse(int logicalSlot)
-            => ((1 << logicalSlot) & _used) != 0;
-
-        private int ComputeLogicalSlot(int hc)
-        {
-            var uc = unchecked((uint)hc);
-            var rotated = RotateRight(uc, _hashRoll);
-            return unchecked((int)(rotated & 31));
-        }
-
-        [Pure]
-        private static uint RotateRight(uint v, int n)
-        {
-            Debug.Assert(n is >= 0 and < 32);
-            if (n == 0)
-            {
-                return v;
-            }
-
-            return v >> n | (v << (32 - n));
-        }
-
-        private int ComputePhysicalSlot(int logicalSlot)
-        {
-            Debug.Assert(logicalSlot is >= 0 and < 32);
-            Contract.Ensures(Contract.Result<int>() >= 0);
-            if (_buckets.Length == 32)
-            {
-                return logicalSlot;
-            }
-
-            if (logicalSlot == 0)
-            {
-                return 0;
-            }
-
-            var mask = uint.MaxValue >> (32 - logicalSlot); // only count the bits up to the logical slot #
-            return CountBits(_used & mask);
-        }
-
-        [Pure]
-        private static int CountBits(uint v)
-        {
-            unchecked
-            {
-                v -= ((v >> 1) & 0x55555555u);
-                v = (v & 0x33333333u) + ((v >> 2) & 0x33333333u);
-                return (int)((v + (v >> 4) & 0xF0F0F0Fu) * 0x1010101u) >> 24;
-            }
-        }
-
-        [Pure]
-        private static uint InsertBit(int position, uint bits)
-        {
-            Debug.Assert(0 == (bits & (1u << position)));
-            return bits | (1u << position);
-        }
-
-        [Pure]
-        private static uint RemoveBit(int position, uint bits)
-        {
-            Debug.Assert(0 != (bits & (1u << position)));
-            return bits & ~(1u << position);
-        }
-    }
-
-    #region IImmutableDictionary<TKey,TValue> Members
-
-    IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Clear()
-        => this.Clear();
-
-    IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Add(TKey key, TValue value)
-        => this.Add(key, value);
-
-    IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItem(TKey key, TValue value)
-        => this.SetItem(key, value);
-
-    IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
-        => this.SetItems(items);
-
-    IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs)
-        => this.AddRange(pairs);
-
-    IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.RemoveRange(IEnumerable<TKey> keys)
-        => this.RemoveRange(keys);
-
-    IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Remove(TKey key)
-        => this.Remove(key);
-
-    #endregion
-
-    /// <summary>
-    /// A simple view of the immutable collection that the debugger can show to the developer.
-    /// </summary>
-    private class DebuggerProxy
-    {
-        /// <summary>
-        /// The collection to be enumerated.
-        /// </summary>
-        private readonly ImmutableHashMap<TKey, TValue> _map;
-
-        /// <summary>
-        /// The simple view of the collection.
-        /// </summary>
-        private KeyValuePair<TKey, TValue>[]? _contents;
-
-        /// <summary>   
-        /// Initializes a new instance of the <see cref="DebuggerProxy"/> class.
-        /// </summary>
-        /// <param name="map">The collection to display in the debugger</param>
-        public DebuggerProxy(ImmutableHashMap<TKey, TValue> map)
-        {
-            Requires.NotNull(map, "map");
-            _map = map;
-        }
-
-        /// <summary>
-        /// Gets a simple debugger-viewable collection.
-        /// </summary>
-        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
-        public KeyValuePair<TKey, TValue>[] Contents
-        {
-            get
-            {
-                _contents ??= _map.ToArray();
-
-                return _contents;
-            }
-        }
-    }
-
-    private static class Requires
-    {
-        [DebuggerStepThrough]
-        public static T NotNullAllowStructs<T>(T value, string parameterName)
-        {
-            if (value == null)
-            {
-                throw new ArgumentNullException(parameterName);
-            }
-
-            return value;
-        }
-
-        [DebuggerStepThrough]
-        public static T NotNull<T>(T value, string parameterName) where T : class
-        {
-            if (value == null)
-            {
-                throw new ArgumentNullException(parameterName);
-            }
-
-            return value;
-        }
-
-        [DebuggerStepThrough]
-        public static Exception FailRange(string parameterName, string? message = null)
-        {
-            if (string.IsNullOrEmpty(message))
-            {
-                throw new ArgumentOutOfRangeException(parameterName);
-            }
-
-            throw new ArgumentOutOfRangeException(parameterName, message);
-        }
-
-        [DebuggerStepThrough]
-        public static void Range(bool condition, string parameterName, string? message = null)
-        {
-            if (!condition)
-            {
-                Requires.FailRange(parameterName, message);
-            }
-        }
-    }
-
-    private static class Strings
-    {
-        public static string DuplicateKey => CompilerExtensionsResources.An_element_with_the_same_key_but_a_different_value_already_exists;
-    }
-}
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CompilerUtilities/ImmutableHashMapExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CompilerUtilities/ImmutableHashMapExtensions.cs
deleted file mode 100644
index 6236cb881c727..0000000000000
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Utilities/CompilerUtilities/ImmutableHashMapExtensions.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Threading;
-using Roslyn.Collections.Immutable;
-
-namespace Roslyn.Utilities;
-
-internal static class ImmutableHashMapExtensions
-{
-    /// <summary>
-    /// Obtains the value for the specified key from a dictionary, or adds a new value to the dictionary where the key did not previously exist.
-    /// </summary>
-    /// <typeparam name="TKey">The type of key stored by the dictionary.</typeparam>
-    /// <typeparam name="TValue">The type of value stored by the dictionary.</typeparam>
-    /// <typeparam name="TArg">The type of argument supplied to the value factory.</typeparam>
-    /// <param name="location">The variable or field to atomically update if the specified <paramref name="key" /> is not in the dictionary.</param>
-    /// <param name="key">The key for the value to retrieve or add.</param>
-    /// <param name="valueProvider">The function to execute to obtain the value to insert into the dictionary if the key is not found. Returns null if the value can't be obtained.</param>
-    /// <param name="factoryArgument">The argument to pass to the value factory.</param>
-    /// <returns>The value obtained from the dictionary or <paramref name="valueProvider" /> if it was not present.</returns>
-    public static TValue? GetOrAdd<TKey, TValue, TArg>(ref ImmutableHashMap<TKey, TValue> location, TKey key, Func<TKey, TArg, TValue?> valueProvider, TArg factoryArgument)
-        where TKey : notnull
-        where TValue : class
-    {
-        Contract.ThrowIfNull(valueProvider);
-
-        var map = Volatile.Read(ref location);
-        Contract.ThrowIfNull(map);
-        if (map.TryGetValue(key, out var existingValue))
-        {
-            return existingValue;
-        }
-
-        var newValue = valueProvider(key, factoryArgument);
-        if (newValue is null)
-        {
-            return null;
-        }
-
-        do
-        {
-            var augmentedMap = map.Add(key, newValue);
-            var replacedMap = Interlocked.CompareExchange(ref location, augmentedMap, map);
-            if (replacedMap == map)
-            {
-                return newValue;
-            }
-
-            map = replacedMap;
-        }
-        while (!map.TryGetValue(key, out existingValue));
-
-        return existingValue;
-    }
-}

From f520a73885f163f6b9f08b9c64eb0fa381ca60ed Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Wed, 13 Mar 2024 19:15:25 -0700
Subject: [PATCH 072/170] Reduce allocations in SynchronizeAssetsAsync (#72533)

This method was allocating an ImmutableArray<Checksum> each time it would request asset synchronization. Instead, we can use a pooled checksum array.
---
 .../Core/Portable/Serialization/PooledList.cs |  7 ++--
 .../Fakes/SimpleAssetSource.cs                |  5 ++-
 .../Remote/Core/ISolutionAssetProvider.cs     |  4 +-
 .../Core/RemoteHostAssetSerialization.cs      |  6 ++-
 .../Remote/Core/SolutionAssetProvider.cs      |  8 ++--
 .../Remote/Core/SolutionAssetStorage.Scope.cs |  3 +-
 .../Remote/ServiceHub/Host/AssetProvider.cs   | 42 +++++++++++++++----
 .../Remote/ServiceHub/Host/IAssetSource.cs    |  3 +-
 .../ServiceHub/Host/SolutionAssetCache.cs     |  3 ++
 .../ServiceHub/Host/SolutionAssetSource.cs    |  3 +-
 10 files changed, 57 insertions(+), 27 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Serialization/PooledList.cs b/src/Workspaces/Core/Portable/Serialization/PooledList.cs
index b6bdcf1bf0522..672612efae0a6 100644
--- a/src/Workspaces/Core/Portable/Serialization/PooledList.cs
+++ b/src/Workspaces/Core/Portable/Serialization/PooledList.cs
@@ -4,9 +4,8 @@
 
 #nullable disable
 
+using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Serialization;
 
@@ -15,12 +14,12 @@ namespace Microsoft.CodeAnalysis.Serialization;
 /// </summary>
 internal static class Creator
 {
-    public static PooledObject<HashSet<Checksum>> CreateChecksumSet(ImmutableArray<Checksum> checksums)
+    public static PooledObject<HashSet<Checksum>> CreateChecksumSet(ReadOnlyMemory<Checksum> checksums)
     {
         var items = SharedPools.Default<HashSet<Checksum>>().GetPooledObject();
 
         var hashSet = items.Object;
-        foreach (var checksum in checksums)
+        foreach (var checksum in checksums.Span)
             hashSet.Add(checksum);
 
         return items;
diff --git a/src/Workspaces/CoreTestUtilities/Fakes/SimpleAssetSource.cs b/src/Workspaces/CoreTestUtilities/Fakes/SimpleAssetSource.cs
index 5f4e31d523c6e..60dd23543517c 100644
--- a/src/Workspaces/CoreTestUtilities/Fakes/SimpleAssetSource.cs
+++ b/src/Workspaces/CoreTestUtilities/Fakes/SimpleAssetSource.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.IO;
@@ -18,11 +19,11 @@ namespace Microsoft.CodeAnalysis.Remote.Testing;
 internal sealed class SimpleAssetSource(ISerializerService serializerService, IReadOnlyDictionary<Checksum, object> map) : IAssetSource
 {
     public ValueTask<ImmutableArray<object>> GetAssetsAsync(
-        Checksum solutionChecksum, AssetHint assetHint, ImmutableArray<Checksum> checksums, ISerializerService deserializerService, CancellationToken cancellationToken)
+        Checksum solutionChecksum, AssetHint assetHint, ReadOnlyMemory<Checksum> checksums, ISerializerService deserializerService, CancellationToken cancellationToken)
     {
         var results = new List<object>();
 
-        foreach (var checksum in checksums)
+        foreach (var checksum in checksums.Span)
         {
             Contract.ThrowIfFalse(map.TryGetValue(checksum, out var data));
 
diff --git a/src/Workspaces/Remote/Core/ISolutionAssetProvider.cs b/src/Workspaces/Remote/Core/ISolutionAssetProvider.cs
index cf98ca3fcacec..b57bf95fcb2b2 100644
--- a/src/Workspaces/Remote/Core/ISolutionAssetProvider.cs
+++ b/src/Workspaces/Remote/Core/ISolutionAssetProvider.cs
@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Collections.Immutable;
+using System;
 using System.IO.Pipelines;
 using System.Threading;
 using System.Threading.Tasks;
@@ -26,5 +26,5 @@ internal interface ISolutionAssetProvider
     /// save substantially on performance by avoiding having to search the full solution tree to find matching items for
     /// a particular checksum.</param>
     ValueTask WriteAssetsAsync(
-        PipeWriter pipeWriter, Checksum solutionChecksum, AssetHint assetHint, ImmutableArray<Checksum> checksums, CancellationToken cancellationToken);
+        PipeWriter pipeWriter, Checksum solutionChecksum, AssetHint assetHint, ReadOnlyMemory<Checksum> checksums, CancellationToken cancellationToken);
 }
diff --git a/src/Workspaces/Remote/Core/RemoteHostAssetSerialization.cs b/src/Workspaces/Remote/Core/RemoteHostAssetSerialization.cs
index 770150e2d5ea1..b7a04d068ce19 100644
--- a/src/Workspaces/Remote/Core/RemoteHostAssetSerialization.cs
+++ b/src/Workspaces/Remote/Core/RemoteHostAssetSerialization.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -24,7 +25,7 @@ public static async ValueTask WriteDataAsync(
             ISerializerService serializer,
             SolutionReplicationContext context,
             Checksum solutionChecksum,
-            ImmutableArray<Checksum> checksums,
+            ReadOnlyMemory<Checksum> checksums,
             CancellationToken cancellationToken)
         {
             using var writer = new ObjectWriter(stream, leaveOpen: true, cancellationToken);
@@ -40,8 +41,9 @@ public static async ValueTask WriteDataAsync(
 
             Debug.Assert(assetMap != null);
 
-            foreach (var checksum in checksums)
+            for (var i = 0; i < checksums.Span.Length; i++)
             {
+                var checksum = checksums.Span[i];
                 var asset = assetMap[checksum];
 
                 // We flush after each item as that forms a reasonably sized chunk of data to want to then send over the
diff --git a/src/Workspaces/Remote/Core/SolutionAssetProvider.cs b/src/Workspaces/Remote/Core/SolutionAssetProvider.cs
index f5952b44f6319..52a3f75670cc7 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetProvider.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetProvider.cs
@@ -4,13 +4,11 @@
 
 using System;
 using System.Buffers;
-using System.Collections.Immutable;
 using System.IO;
 using System.IO.Pipelines;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
-using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Serialization;
 using Roslyn.Utilities;
 
@@ -31,7 +29,7 @@ public ValueTask WriteAssetsAsync(
             PipeWriter pipeWriter,
             Checksum solutionChecksum,
             AssetHint assetHint,
-            ImmutableArray<Checksum> checksums,
+            ReadOnlyMemory<Checksum> checksums,
             CancellationToken cancellationToken)
         {
             // Suppress ExecutionContext flow for asynchronous operations operate on the pipe. In addition to avoiding
@@ -43,7 +41,7 @@ public ValueTask WriteAssetsAsync(
             using var _ = FlowControlHelper.TrySuppressFlow();
             return WriteAssetsSuppressedFlowAsync(pipeWriter, solutionChecksum, assetHint, checksums, cancellationToken);
 
-            async ValueTask WriteAssetsSuppressedFlowAsync(PipeWriter pipeWriter, Checksum solutionChecksum, AssetHint assetHint, ImmutableArray<Checksum> checksums, CancellationToken cancellationToken)
+            async ValueTask WriteAssetsSuppressedFlowAsync(PipeWriter pipeWriter, Checksum solutionChecksum, AssetHint assetHint, ReadOnlyMemory<Checksum> checksums, CancellationToken cancellationToken)
             {
                 // The responsibility is on us (as per the requirements of RemoteCallback.InvokeAsync) to Complete the
                 // pipewriter.  This will signal to streamjsonrpc that the writer passed into it is complete, which will
@@ -68,7 +66,7 @@ private async ValueTask WriteAssetsWorkerAsync(
             PipeWriter pipeWriter,
             Checksum solutionChecksum,
             AssetHint assetHint,
-            ImmutableArray<Checksum> checksums,
+            ReadOnlyMemory<Checksum> checksums,
             CancellationToken cancellationToken)
         {
             var assetStorage = _services.GetRequiredService<ISolutionAssetStorageProvider>().AssetStorage;
diff --git a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
index a87a15de4cfcb..ce07e27e23cb1 100644
--- a/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
+++ b/src/Workspaces/Remote/Core/SolutionAssetStorage.Scope.cs
@@ -4,7 +4,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -47,7 +46,7 @@ public void Dispose()
         /// </summary>
         public async Task AddAssetsAsync(
             AssetHint assetHint,
-            ImmutableArray<Checksum> checksums,
+            ReadOnlyMemory<Checksum> checksums,
             Dictionary<Checksum, object> assetMap,
             CancellationToken cancellationToken)
         {
diff --git a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
index 4c0fe1193a253..75758a70003ab 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
@@ -21,6 +21,9 @@ namespace Microsoft.CodeAnalysis.Remote;
 internal sealed partial class AssetProvider(Checksum solutionChecksum, SolutionAssetCache assetCache, IAssetSource assetSource, ISerializerService serializerService)
     : AbstractAssetProvider
 {
+    private const int PooledChecksumArraySize = 256;
+    private static readonly ObjectPool<Checksum[]> s_checksumPool = new(() => new Checksum[PooledChecksumArraySize], 16);
+
     private readonly Checksum _solutionChecksum = solutionChecksum;
     private readonly ISerializerService _serializerService = serializerService;
     private readonly SolutionAssetCache _assetCache = assetCache;
@@ -118,27 +121,50 @@ public async ValueTask SynchronizeAssetsAsync(
 
         using (Logger.LogBlock(FunctionId.AssetService_SynchronizeAssetsAsync, Checksum.GetChecksumsLogInfo, checksums, cancellationToken))
         {
-            using var _1 = ArrayBuilder<Checksum>.GetInstance(checksums.Count, out var missingChecksums);
+            var missingChecksumsCount = 0;
+
+            // Calculate the number of missing checksums upfront. Calculation is cheap and can help avoid extraneous allocations.
+            foreach (var checksum in checksums)
+            {
+                if (!_assetCache.ContainsAsset(checksum))
+                    missingChecksumsCount++;
+            }
+
+            var usePool = missingChecksumsCount <= PooledChecksumArraySize;
+            var missingChecksums = usePool ? s_checksumPool.Allocate() : new Checksum[missingChecksumsCount];
+
+            missingChecksumsCount = 0;
             foreach (var checksum in checksums)
             {
                 if (!_assetCache.TryGetAsset<object>(checksum, out _))
-                    missingChecksums.Add(checksum);
+                {
+                    missingChecksums[missingChecksumsCount] = checksum;
+                    missingChecksumsCount++;
+                }
             }
 
-            var checksumsArray = missingChecksums.ToImmutableAndClear();
-            var assets = await RequestAssetsAsync(assetHint, checksumsArray, cancellationToken).ConfigureAwait(false);
+            var missingChecksumsMemory = new ReadOnlyMemory<Checksum>(missingChecksums, 0, missingChecksumsCount);
+            var assets = await RequestAssetsAsync(assetHint, missingChecksumsMemory, cancellationToken).ConfigureAwait(false);
 
-            Contract.ThrowIfTrue(checksumsArray.Length != assets.Length);
+            Contract.ThrowIfTrue(missingChecksumsMemory.Length != assets.Length);
 
             for (int i = 0, n = assets.Length; i < n; i++)
-                _assetCache.GetOrAdd(checksumsArray[i], assets[i]);
+                _assetCache.GetOrAdd(missingChecksums[i], assets[i]);
+
+            if (usePool)
+                s_checksumPool.Free(missingChecksums);
         }
     }
 
     private async Task<ImmutableArray<object>> RequestAssetsAsync(
-        AssetHint assetHint, ImmutableArray<Checksum> checksums, CancellationToken cancellationToken)
+        AssetHint assetHint, ReadOnlyMemory<Checksum> checksums, CancellationToken cancellationToken)
     {
-        Contract.ThrowIfTrue(checksums.Contains(Checksum.Null));
+#if NETCOREAPP
+        Contract.ThrowIfTrue(checksums.Span.Contains(Checksum.Null));
+#else
+        Contract.ThrowIfTrue(checksums.Span.IndexOf(Checksum.Null) >= 0);
+#endif
+
         if (checksums.Length == 0)
             return [];
 
diff --git a/src/Workspaces/Remote/ServiceHub/Host/IAssetSource.cs b/src/Workspaces/Remote/ServiceHub/Host/IAssetSource.cs
index cc8f9f1573087..840e043daa46a 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/IAssetSource.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/IAssetSource.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
@@ -15,5 +16,5 @@ namespace Microsoft.CodeAnalysis.Remote;
 internal interface IAssetSource
 {
     ValueTask<ImmutableArray<object>> GetAssetsAsync(
-        Checksum solutionChecksum, AssetHint assetHint, ImmutableArray<Checksum> checksums, ISerializerService serializerService, CancellationToken cancellationToken);
+        Checksum solutionChecksum, AssetHint assetHint, ReadOnlyMemory<Checksum> checksums, ISerializerService serializerService, CancellationToken cancellationToken);
 }
diff --git a/src/Workspaces/Remote/ServiceHub/Host/SolutionAssetCache.cs b/src/Workspaces/Remote/ServiceHub/Host/SolutionAssetCache.cs
index f41418215977f..c167b7162380b 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/SolutionAssetCache.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/SolutionAssetCache.cs
@@ -111,6 +111,9 @@ public bool TryGetAsset<T>(Checksum checksum, [MaybeNullWhen(false)] out T value
             }
         }
 
+        public bool ContainsAsset(Checksum checksum)
+            => _assets.ContainsKey(checksum);
+
         public void UpdateLastActivityTime()
             => _lastActivityTime = DateTime.UtcNow;
 
diff --git a/src/Workspaces/Remote/ServiceHub/Host/SolutionAssetSource.cs b/src/Workspaces/Remote/ServiceHub/Host/SolutionAssetSource.cs
index 75b05acd026bb..4917033beae78 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/SolutionAssetSource.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/SolutionAssetSource.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
@@ -18,7 +19,7 @@ internal sealed class SolutionAssetSource(ServiceBrokerClient client) : IAssetSo
     public async ValueTask<ImmutableArray<object>> GetAssetsAsync(
         Checksum solutionChecksum,
         AssetHint assetHint,
-        ImmutableArray<Checksum> checksums,
+        ReadOnlyMemory<Checksum> checksums,
         ISerializerService serializerService,
         CancellationToken cancellationToken)
     {

From 26b809df38356d4fe1ee376f703dc8832a7ce461 Mon Sep 17 00:00:00 2001
From: Jan Jones <janjones@microsoft.com>
Date: Thu, 14 Mar 2024 10:50:24 +0100
Subject: [PATCH 073/170] Check PublishData.json feeds (#72333)

* Update BuildBoss docs

* Check PublishData.json
---
 .../BuildBoss/CompilerNuGetCheckerUtil.cs     | 42 ++++++++++++++++++-
 src/Tools/BuildBoss/ProjectCheckerUtil.cs     |  2 +-
 src/Tools/BuildBoss/README.md                 |  8 ++--
 3 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/src/Tools/BuildBoss/CompilerNuGetCheckerUtil.cs b/src/Tools/BuildBoss/CompilerNuGetCheckerUtil.cs
index c22b54c64f2d4..95268daf87b17 100644
--- a/src/Tools/BuildBoss/CompilerNuGetCheckerUtil.cs
+++ b/src/Tools/BuildBoss/CompilerNuGetCheckerUtil.cs
@@ -15,6 +15,7 @@
 using System.Reflection.PortableExecutable;
 using System.Security.Cryptography;
 using System.Text.RegularExpressions;
+using Newtonsoft.Json.Linq;
 
 namespace BuildBoss
 {
@@ -72,6 +73,7 @@ public bool Check(TextWriter textWriter)
             try
             {
                 var allGood = true;
+                allGood &= CheckPublishData(textWriter);
                 allGood &= CheckPackages(textWriter);
                 allGood &= CheckExternalApis(textWriter);
                 return allGood;
@@ -83,6 +85,44 @@ public bool Check(TextWriter textWriter)
             }
         }
 
+        /// <summary>
+        /// Verify PublishData.json contains feeds for all packages that will be published.
+        /// </summary>
+        private bool CheckPublishData(TextWriter textWriter)
+        {
+            var allGood = true;
+
+            // Load PublishData.json
+            var publishDataPath = Path.Combine(RepositoryDirectory, "eng", "config", "PublishData.json");
+            var publishDataRoot = JObject.Parse(File.ReadAllText(publishDataPath));
+            var publishDataPackages = publishDataRoot["packages"]["default"] as JObject;
+
+            // Check all shipping packages have an entry in PublishData.json
+            var regex = new Regex(@"^(.*?)\.\d.*\.nupkg$");
+            var packagesDirectory = Path.Combine(ArtifactsDirectory, "packages", Configuration, "Shipping");
+            foreach (var packageFullPath in Directory.EnumerateFiles(packagesDirectory, "*.nupkg"))
+            {
+                var packageFileName = Path.GetFileName(packageFullPath);
+                var match = regex.Match(packageFileName);
+                if (!match.Success)
+                {
+                    allGood = false;
+                    textWriter.WriteLine($"Unexpected package file name '{packageFileName}'");
+                }
+                else
+                {
+                    var packageId = match.Groups[1].Value;
+                    if (!publishDataPackages.ContainsKey(packageId))
+                    {
+                        allGood = false;
+                        textWriter.WriteLine($"Package doesn't have corresponding PublishData.json entry: {packageId} ({packageFileName})");
+                    }
+                }
+            }
+
+            return allGood;
+        }
+
         /// <summary>
         /// Verify the contents of the compiler packages match the expected input
         /// </summary>
@@ -360,7 +400,7 @@ void verifyFolder(string folderRelativeName)
                 }
 
                 // As a simplification we only validate the assembly names that begin with Microsoft.CodeAnalysis. This is a good 
-                // hueristic for finding assemblies that we build. Can be expanded in the future if we find more assemblies that
+                // heuristic for finding assemblies that we build. Can be expanded in the future if we find more assemblies that
                 // are worth validating here.
                 var neededDllNames = neededDllNameSet
                     .Where(x => x.StartsWith("Microsoft.CodeAnalysis"))
diff --git a/src/Tools/BuildBoss/ProjectCheckerUtil.cs b/src/Tools/BuildBoss/ProjectCheckerUtil.cs
index 9c7555b2d8081..30169fa97809f 100644
--- a/src/Tools/BuildBoss/ProjectCheckerUtil.cs
+++ b/src/Tools/BuildBoss/ProjectCheckerUtil.cs
@@ -174,7 +174,7 @@ private bool CheckDeploymentSettings(TextWriter textWriter)
 
         /// <summary>
         /// It's important that every reference be included in the solution.  MSBuild does not necessarily
-        /// apply all configuration entries to projects which are compiled via referenes but not included
+        /// apply all configuration entries to projects which are compiled via references but not included
         /// in the solution.
         /// </summary>
         private bool CheckProjectReferencesComplete(TextWriter textWriter, IEnumerable<ProjectKey> declaredReferences)
diff --git a/src/Tools/BuildBoss/README.md b/src/Tools/BuildBoss/README.md
index 7bea1ca910e33..c431f2575e9b8 100644
--- a/src/Tools/BuildBoss/README.md
+++ b/src/Tools/BuildBoss/README.md
@@ -6,7 +6,7 @@ This is a tool to validate the state of our solutions, project files and other b
 > BuildBoss.exe <solution / project / targets path / build log paths>
 ```
 
-This tool is run on every CI job against our important solution files: [Roslyn.sln](https://github.com/dotnet/roslyn/blob/main/Roslyn.sln), and [CrossPlatform.sln](https://github.com/dotnet/roslyn/blob/main/CrossPlatform.sln).  
+This tool is run on every CI job against our important solution files: [Roslyn.sln](https://github.com/dotnet/roslyn/blob/main/Roslyn.sln).
 
 Violations reported are important to fix as they represent correctness issues in our build.  Many of the properties verified represent problems that otherwise won't be verified at check in time.
 
@@ -39,13 +39,13 @@ There are a number of properties which are simply unnecessary for build.  They a
 
 ### Transitive references
 
-Projects which represent full deployments must have a complete set of project references declared in the project file. Or in other words the declared set of project references much match the tranistive closure of project references. Any gap between the two sets won't be deployed on build which in turn will break F5, testing, etc ...
+Projects which represent full deployments must have a complete set of project references declared in the project file. Or in other words the declared set of project references much match the transitive closure of project references. Any gap between the two sets won't be deployed on build which in turn will break F5, testing, etc ...
 
 ### Classifying projects
 
 Our build process depends on being able to correctly classify our projects: exe, VSIX, dll, etc ...  This can typically be inferred from properties like OutputType.  But in other occasions it requires a more declarative entry via the `<RoslynProjectType>` property.  The tool will catch places where projects are incorrectly classified.
 
-This could be done using MSBuild targets but the logic is hard to follow and complicates the build.  It's easier and more readable to have a declaritive entry in the file.
+This could be done using MSBuild targets but the logic is hard to follow and complicates the build.  It's easier and more readable to have a declarative entry in the file.
 
 ## Solution Content Verified
 
@@ -57,7 +57,7 @@ This is best demonstrated by example.  Consider the following setup:
 - Project App.csproj produces App.exe and references Util.csproj
 - Solution App.sln includes App.csproj only
 
-Now consider when App.sln is build with the following command line:
+Now consider when App.sln is built with the following command line:
 
 ``` cmd
 msbuild /p:Configuration=Release App.sln

From 224f1a3005fbd209aba051c855ecf23305094c6c Mon Sep 17 00:00:00 2001
From: andrei-ungureanu-uipath
 <61829128+andrei-ungureanu-uipath@users.noreply.github.com>
Date: Thu, 14 Mar 2024 15:57:52 +0200
Subject: [PATCH 074/170] Fix InvalidCastException when initializing the
 properties of an undeclared class inside a lambda function (#72480)

Fixes https://github.com/dotnet/roslyn/issues/72456.

Building the following snippet in a VB project breaks the compilation:
```vb
Imports System
Imports System.Linq.Expressions
Module Program
    Public Function CreateExpression() As Expression(Of Func(Of Object))
        Return Function() (New UndeclaredClass() With {.Name = "testName"})
    End Function
End Module
```

There is a difference between `VisualBasic` and `CSharp` when getting diagnostics for the snippet above. The latter checks for the initializer type while the former forces a `DirectCast` which throws an `InvalidCastException`. This PR checks the type before forcing the cast similar to the `CSharp` approach.

### Expected result
`Error BC30002: Type 'UndeclaredClass' is not defined.`
### Actual result
Compilation breaks with the following trace:
```
System.InvalidCastException
  HResult=0x80004002
  Message=Unable to cast object of type 'Microsoft.CodeAnalysis.VisualBasic.BoundLiteral' to type 'Microsoft.CodeAnalysis.VisualBasic.BoundAssignmentOperator'.

This exception was originally thrown at this call stack:
Microsoft.CodeAnalysis.VisualBasic.dll!Microsoft.CodeAnalysis.VisualBasic.DiagnosticsPass.VisitObjectInitializerExpression(Microsoft.CodeAnalysis.VisualBasic.BoundObjectInitializerExpression node) Line 126	Basic
Microsoft.CodeAnalysis.VisualBasic.dll!Microsoft.CodeAnalysis.VisualBasic.BoundObjectInitializerExpression.Accept(Microsoft.CodeAnalysis.VisualBasic.BoundTreeVisitor visitor) Line 3792	Basic
Microsoft.CodeAnalysis.VisualBasic.dll!Microsoft.CodeAnalysis.VisualBasic.BoundTreeWalkerWithStackGuard.VisitExpressionWithoutStackGuard(Microsoft.CodeAnalysis.VisualBasic.BoundExpression node) Line 61	Basic
Microsoft.CodeAnalysis.VisualBasic.dll!Microsoft.CodeAnalysis.VisualBasic.BoundTreeVisitor.VisitExpressionWithStackGuard(Integer recursionDepth, Microsoft.CodeAnalysis.VisualBasic.BoundExpression node) Line 186	Basic
Microsoft.CodeAnalysis.VisualBasic.dll!Microsoft.CodeAnalysis.VisualBasic.BoundTreeWalkerWithStackGuard.Visit(Microsoft.CodeAnalysis.VisualBasic.BoundNode node) Line 50	Basic
Microsoft.CodeAnalysis.VisualBasic.dll!Microsoft.CodeAnalysis.VisualBasic.DiagnosticsPass.Visit(Microsoft.CodeAnalysis.VisualBasic.BoundNode node) Line 208	Basic
...
```
---
 .../DiagnosticsPass_ExpressionLambdas.vb      | 19 ++++++++------
 .../Emit/ExpressionTrees/CodeGenExprLambda.vb | 25 +++++++++++++++++++
 2 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/src/Compilers/VisualBasic/Portable/Lowering/Diagnostics/DiagnosticsPass_ExpressionLambdas.vb b/src/Compilers/VisualBasic/Portable/Lowering/Diagnostics/DiagnosticsPass_ExpressionLambdas.vb
index cc1ca0a3d268c..cc44e74774a88 100644
--- a/src/Compilers/VisualBasic/Portable/Lowering/Diagnostics/DiagnosticsPass_ExpressionLambdas.vb
+++ b/src/Compilers/VisualBasic/Portable/Lowering/Diagnostics/DiagnosticsPass_ExpressionLambdas.vb
@@ -122,16 +122,19 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
             For Each initializer In node.Initializers
                 ' Ignore assignments in object initializers, only reference the value
-                Debug.Assert(initializer.Kind = BoundKind.AssignmentOperator)
-                Dim assignment = DirectCast(initializer, BoundAssignmentOperator)
-                Debug.Assert(assignment.LeftOnTheRightOpt Is Nothing)
-
-                Dim propertyAccess = TryCast(assignment.Left, BoundPropertyAccess)
-                If propertyAccess IsNot Nothing Then
-                    CheckRefReturningPropertyAccess(propertyAccess)
+                Dim boundExpression As BoundExpression = initializer
+                If boundExpression.Kind = BoundKind.AssignmentOperator Then
+                    Dim assignment = DirectCast(initializer, BoundAssignmentOperator)
+                    Debug.Assert(assignment.LeftOnTheRightOpt Is Nothing)
+
+                    boundExpression = assignment.Right
+                    Dim propertyAccess = TryCast(assignment.Left, BoundPropertyAccess)
+                    If propertyAccess IsNot Nothing Then
+                        CheckRefReturningPropertyAccess(propertyAccess)
+                    End If
                 End If
 
-                Me.Visit(assignment.Right)
+                Me.Visit(boundExpression)
             Next
 
             Me._expressionTreePlaceholders.Remove(placeholder)
diff --git a/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb b/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
index 9b2bb516786c7..f7d0a425cadfe 100644
--- a/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
@@ -2015,6 +2015,31 @@ End Module
             CompileAndVerify(source, references:={Net40.SystemCore}).VerifyDiagnostics()
         End Sub
 
+        <Fact, WorkItem("https://github.com/dotnet/roslyn/issues/72456")>
+        Public Sub UndeclaredClassInLambdaFunction()
+            Dim source =
+<compilation>
+    <file name="expr.vb"><![CDATA[
+Imports System
+Imports System.Linq.Expressions
+Module Program
+    Public Function CreateExpression() As Expression(Of Func(Of Object))
+        Return Function() (New UndeclaredClass() With {.Name = "testName"})
+    End Function
+End Module
+]]>
+    </file>
+</compilation>
+
+            Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(source, {LinqAssemblyRef})
+            AssertTheseDiagnostics(compilation.GetDiagnostics(),
+<expected>
+BC30002: Type 'UndeclaredClass' is not defined.
+        Return Function() (New UndeclaredClass() With {.Name = "testName"})
+                               ~~~~~~~~~~~~~~~
+</expected>)
+        End Sub
+
         <Fact>
         <WorkItem(577271, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/577271")>
         Public Sub Bug577271()

From 0862838a8bd02d6eb6901968feb76f94e10305e6 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Thu, 14 Mar 2024 16:32:10 -0700
Subject: [PATCH 075/170] Add explicit package reference to
 System.Threading.Tasks.Dataflow

in Microsoft.CodeAnalysis.InteractiveHost to ensure it's included for binding redirect
---
 .../Host/Microsoft.CodeAnalysis.InteractiveHost.csproj           | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj b/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
index c4cd1fa0ad9ae..d59e3214b13ef 100644
--- a/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
+++ b/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
@@ -68,6 +68,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="StreamJsonRpc" />
+    <PackageReference Include="System.Threading.Tasks.Dataflow" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Update="InteractiveHostResources.resx" GenerateSource="true" />

From 3b5b0d90eb507e6d25a978a08605f693e9d022e7 Mon Sep 17 00:00:00 2001
From: "gel@microsoft.com" <gel@microsoft.com>
Date: Thu, 14 Mar 2024 16:57:13 -0700
Subject: [PATCH 076/170] Add comment

---
 .../Host/Microsoft.CodeAnalysis.InteractiveHost.csproj         | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj b/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
index d59e3214b13ef..002cd61d995fe 100644
--- a/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
+++ b/src/Interactive/Host/Microsoft.CodeAnalysis.InteractiveHost.csproj
@@ -68,6 +68,9 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="StreamJsonRpc" />
+    <!-- Due to the limitation of our BindingRedirect generation logic, 
+    add an explicit reference to System.Threading.Tasks.Dataflow to ensure that the correct
+     BindingRedirect is included in the app.config of InteractiveHost.exe -->
     <PackageReference Include="System.Threading.Tasks.Dataflow" />
   </ItemGroup>
   <ItemGroup>

From b77e47048af837a8c67dcdc0a4aaf1fd907cb76e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Thu, 14 Mar 2024 17:52:21 -0700
Subject: [PATCH 077/170] Fix tests

---
 .../Diagnostics/AdditionalFileDiagnosticsTests.cs         | 8 ++------
 .../Diagnostics/WorkspaceProjectDiagnosticsTests.cs       | 4 +---
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/AdditionalFileDiagnosticsTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/AdditionalFileDiagnosticsTests.cs
index 5101f94f107fc..3b4e20e082b7d 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/AdditionalFileDiagnosticsTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/AdditionalFileDiagnosticsTests.cs
@@ -47,10 +47,7 @@ public async Task TestWorkspaceDiagnosticsReportsAdditionalFileDiagnostic(bool u
 
         // Asking again should give us back an unchanged diagnostic.
         var results2 = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics, previousResults: CreateDiagnosticParamsFromPreviousReports(results));
-        Assert.Null(results2[0].Diagnostics);
-        Assert.Null(results2[1].Diagnostics);
-        Assert.Equal(results[1].ResultId, results2[1].ResultId);
-        Assert.Null(results2[2].Diagnostics);
+        Assert.Empty(results2);
     }
 
     [Theory, CombinatorialData]
@@ -121,8 +118,7 @@ public async Task TestWorkspaceDiagnosticsWithAdditionalFileInMultipleProjects(b
 
         // Asking again should give us back an unchanged diagnostic.
         var results2 = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics: true, previousResults: CreateDiagnosticParamsFromPreviousReports(results));
-        Assert.Equal(results[1].ResultId, results2[1].ResultId);
-        Assert.Equal(results[4].ResultId, results2[4].ResultId);
+        Assert.Empty(results2);
     }
 
     protected override TestComposition Composition => base.Composition.AddParts(typeof(MockAdditionalFileDiagnosticAnalyzer));
diff --git a/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/WorkspaceProjectDiagnosticsTests.cs b/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/WorkspaceProjectDiagnosticsTests.cs
index 2a744e63008ca..fd7f64bb4e005 100644
--- a/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/WorkspaceProjectDiagnosticsTests.cs
+++ b/src/Features/LanguageServer/ProtocolUnitTests/Diagnostics/WorkspaceProjectDiagnosticsTests.cs
@@ -37,9 +37,7 @@ public async Task TestWorkspaceDiagnosticsReportsProjectDiagnostic(bool useVSDia
 
         // Asking again should give us back an unchanged diagnostic.
         var results2 = await RunGetWorkspacePullDiagnosticsAsync(testLspServer, useVSDiagnostics, previousResults: CreateDiagnosticParamsFromPreviousReports(results));
-        Assert.Null(results2[0].Diagnostics);
-        Assert.Null(results2[1].Diagnostics);
-        Assert.Equal(results[1].ResultId, results2[1].ResultId);
+        Assert.Empty(results2);
     }
 
     [Theory, CombinatorialData]

From 6f42d5db3e8794a074748e42b1ba6304d47cc606 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Thu, 14 Mar 2024 18:07:42 -0700
Subject: [PATCH 078/170] Have pull-diagnostics respect the flag to to not run
 during perf runs

---
 ...acySolutionEventsWorkspaceEventListener.cs |   4 +-
 .../AbstractPullDiagnosticHandler.cs          | 131 ++++++++++--------
 2 files changed, 73 insertions(+), 62 deletions(-)

diff --git a/src/EditorFeatures/Core/SolutionEvents/HostLegacySolutionEventsWorkspaceEventListener.cs b/src/EditorFeatures/Core/SolutionEvents/HostLegacySolutionEventsWorkspaceEventListener.cs
index 9c34bcc14bbca..12535d5b92067 100644
--- a/src/EditorFeatures/Core/SolutionEvents/HostLegacySolutionEventsWorkspaceEventListener.cs
+++ b/src/EditorFeatures/Core/SolutionEvents/HostLegacySolutionEventsWorkspaceEventListener.cs
@@ -49,8 +49,8 @@ public HostLegacySolutionEventsWorkspaceEventListener(
 
     public void StartListening(Workspace workspace, object? serviceOpt)
     {
-        // We only support this option to disable crawling in internal perf runs to lower noise.  It is not exposed to
-        // the user.
+        // We only support this option to disable crawling in internal speedometer and ddrit perf runs to lower noise.
+        // It is not exposed to the user.
         if (_globalOptions.GetOption(SolutionCrawlerRegistrationService.EnableSolutionCrawler))
         {
             workspace.WorkspaceChanged += OnWorkspaceChanged;
diff --git a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
index e3869cb792c71..6880b9ff808bd 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.LanguageServer.Features.Diagnostics;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.SolutionCrawler;
 using Microsoft.CommonLanguageServerProtocol.Framework;
 using Roslyn.LanguageServer.Protocol;
 using Roslyn.Utilities;
@@ -130,80 +131,90 @@ protected virtual Task WaitForChangesAsync(RequestContext context, CancellationT
         public async Task<TReturn?> HandleRequestAsync(
             TDiagnosticsParams diagnosticsParams, RequestContext context, CancellationToken cancellationToken)
         {
-            var clientCapabilities = context.GetRequiredClientCapabilities();
-            var category = GetDiagnosticCategory(diagnosticsParams) ?? "";
-            var sourceIdentifier = GetDiagnosticSourceIdentifier(diagnosticsParams) ?? "";
-            var handlerName = $"{this.GetType().Name}(category: {category}, source: {sourceIdentifier})";
-            context.TraceInformation($"{handlerName} started getting diagnostics");
-
-            var versionedCache = _categoryToVersionedCache.GetOrAdd(handlerName, static handlerName => new(handlerName));
-
             // The progress object we will stream reports to.
             using var progress = BufferedProgress.Create(diagnosticsParams.PartialResultToken);
 
-            // Get the set of results the request said were previously reported.  We can use this to determine both
-            // what to skip, and what files we have to tell the client have been removed.
-            var previousResults = GetPreviousResults(diagnosticsParams) ?? [];
-            context.TraceInformation($"previousResults.Length={previousResults.Length}");
+            // We only support this option to disable crawling in internal speedometer and ddrit perf runs to lower
+            // noise.  It is not exposed to the user.
+            if (!this.GlobalOptions.GetOption(SolutionCrawlerRegistrationService.EnableSolutionCrawler))
+            {
+                context.TraceInformation($"{this.GetType()}. Skipping due to {nameof(SolutionCrawlerRegistrationService.EnableSolutionCrawler)}={false}");
+            }
+            else
+            {
+                var clientCapabilities = context.GetRequiredClientCapabilities();
+                var category = GetDiagnosticCategory(diagnosticsParams) ?? "";
+                var sourceIdentifier = GetDiagnosticSourceIdentifier(diagnosticsParams) ?? "";
+                var handlerName = $"{this.GetType().Name}(category: {category}, source: {sourceIdentifier})";
+                context.TraceInformation($"{handlerName} started getting diagnostics");
+
+                var versionedCache = _categoryToVersionedCache.GetOrAdd(handlerName, static handlerName => new(handlerName));
 
-            // Create a mapping from documents to the previous results the client says it has for them.  That way as we
-            // process documents we know if we should tell the client it should stay the same, or we can tell it what
-            // the updated diagnostics are.
-            var documentToPreviousDiagnosticParams = GetIdToPreviousDiagnosticParams(context, previousResults, out var removedResults);
+                // Get the set of results the request said were previously reported.  We can use this to determine both
+                // what to skip, and what files we have to tell the client have been removed.
+                var previousResults = GetPreviousResults(diagnosticsParams) ?? [];
+                context.TraceInformation($"previousResults.Length={previousResults.Length}");
 
-            // First, let the client know if any workspace documents have gone away.  That way it can remove those for
-            // the user from squiggles or error-list.
-            HandleRemovedDocuments(context, removedResults, progress);
+                // Create a mapping from documents to the previous results the client says it has for them.  That way as we
+                // process documents we know if we should tell the client it should stay the same, or we can tell it what
+                // the updated diagnostics are.
+                var documentToPreviousDiagnosticParams = GetIdToPreviousDiagnosticParams(context, previousResults, out var removedResults);
 
-            // Next process each file in priority order. Determine if diagnostics are changed or unchanged since the
-            // last time we notified the client.  Report back either to the client so they can update accordingly.
-            var orderedSources = await GetOrderedDiagnosticSourcesAsync(
-                diagnosticsParams, context, cancellationToken).ConfigureAwait(false);
+                // First, let the client know if any workspace documents have gone away.  That way it can remove those for
+                // the user from squiggles or error-list.
+                HandleRemovedDocuments(context, removedResults, progress);
 
-            context.TraceInformation($"Processing {orderedSources.Length} documents");
+                // Next process each file in priority order. Determine if diagnostics are changed or unchanged since the
+                // last time we notified the client.  Report back either to the client so they can update accordingly.
+                var orderedSources = await GetOrderedDiagnosticSourcesAsync(
+                    diagnosticsParams, context, cancellationToken).ConfigureAwait(false);
 
-            foreach (var diagnosticSource in orderedSources)
-            {
-                var globalStateVersion = _diagnosticRefresher.GlobalStateVersion;
-
-                var project = diagnosticSource.GetProject();
-
-                var newResultId = await versionedCache.GetNewResultIdAsync(
-                    documentToPreviousDiagnosticParams,
-                    diagnosticSource.GetId(),
-                    project,
-                    computeCheapVersionAsync: async () => (globalStateVersion, await project.GetDependentVersionAsync(cancellationToken).ConfigureAwait(false)),
-                    computeExpensiveVersionAsync: async () => (globalStateVersion, await project.GetDependentChecksumAsync(cancellationToken).ConfigureAwait(false)),
-                    cancellationToken).ConfigureAwait(false);
-                if (newResultId != null)
-                {
-                    await ComputeAndReportCurrentDiagnosticsAsync(
-                        context, diagnosticSource, progress, newResultId, clientCapabilities, cancellationToken).ConfigureAwait(false);
-                }
-                else
+                context.TraceInformation($"Processing {orderedSources.Length} documents");
+
+                foreach (var diagnosticSource in orderedSources)
                 {
-                    context.TraceInformation($"Diagnostics were unchanged for {diagnosticSource.ToDisplayString()}");
+                    var globalStateVersion = _diagnosticRefresher.GlobalStateVersion;
+
+                    var project = diagnosticSource.GetProject();
+
+                    var newResultId = await versionedCache.GetNewResultIdAsync(
+                        documentToPreviousDiagnosticParams,
+                        diagnosticSource.GetId(),
+                        project,
+                        computeCheapVersionAsync: async () => (globalStateVersion, await project.GetDependentVersionAsync(cancellationToken).ConfigureAwait(false)),
+                        computeExpensiveVersionAsync: async () => (globalStateVersion, await project.GetDependentChecksumAsync(cancellationToken).ConfigureAwait(false)),
+                        cancellationToken).ConfigureAwait(false);
+                    if (newResultId != null)
+                    {
+                        await ComputeAndReportCurrentDiagnosticsAsync(
+                            context, diagnosticSource, progress, newResultId, clientCapabilities, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        context.TraceInformation($"Diagnostics were unchanged for {diagnosticSource.ToDisplayString()}");
 
-                    // Nothing changed between the last request and this one.  Report a (null-diagnostics,
-                    // same-result-id) response to the client as that means they should just preserve the current
-                    // diagnostics they have for this file.
-                    var previousParams = documentToPreviousDiagnosticParams[diagnosticSource.GetId()];
-                    progress.Report(CreateUnchangedReport(previousParams.TextDocument, previousParams.PreviousResultId));
+                        // Nothing changed between the last request and this one.  Report a (null-diagnostics,
+                        // same-result-id) response to the client as that means they should just preserve the current
+                        // diagnostics they have for this file.
+                        var previousParams = documentToPreviousDiagnosticParams[diagnosticSource.GetId()];
+                        progress.Report(CreateUnchangedReport(previousParams.TextDocument, previousParams.PreviousResultId));
+                    }
                 }
-            }
 
-            // Clear out the solution context to avoid retaining memory
-            // https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1809058
-            context.ClearSolutionContext();
+                // Clear out the solution context to avoid retaining memory
+                // https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1809058
+                context.ClearSolutionContext();
 
-            // Some implementations of the spec will re-open requests as soon as we close them, spamming the server.
-            // In those cases, we wait for the implementation to indicate that changes have occurred, then we close the connection
-            // so that the client asks us again.
-            await WaitForChangesAsync(context, cancellationToken).ConfigureAwait(false);
+                // Some implementations of the spec will re-open requests as soon as we close them, spamming the server.
+                // In those cases, we wait for the implementation to indicate that changes have occurred, then we close the connection
+                // so that the client asks us again.
+                await WaitForChangesAsync(context, cancellationToken).ConfigureAwait(false);
+
+                // If we had a progress object, then we will have been reporting to that.  Otherwise, take what we've been
+                // collecting and return that.
+                context.TraceInformation($"{this.GetType()} finished getting diagnostics");
+            }
 
-            // If we had a progress object, then we will have been reporting to that.  Otherwise, take what we've been
-            // collecting and return that.
-            context.TraceInformation($"{this.GetType()} finished getting diagnostics");
             return CreateReturn(progress);
         }
 

From 616fc283e903e534fc878538ea8bca99b41fd459 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Thu, 14 Mar 2024 19:20:29 -0700
Subject: [PATCH 079/170] Remove stale test

---
 .../DiagnosticAnalyzerServiceTests.cs         | 75 -------------------
 1 file changed, 75 deletions(-)

diff --git a/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs b/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs
index a366b436a54c9..ec4590845f359 100644
--- a/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs
+++ b/src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs
@@ -942,81 +942,6 @@ void M()
             }
         }
 
-        [Theory, CombinatorialData]
-        internal async Task TestCancellationDuringDiagnosticComputation_InProc(AnalyzerRegisterActionKind actionKind)
-        {
-            // This test verifies that we do no attempt to re-use CompilationWithAnalyzers instance in IDE in-proc diagnostic computation in presence of an OperationCanceledException during analysis.
-            // Attempting to do so has led to large number of reliability issues and flakiness in diagnostic computation, which we want to avoid.
-
-            var source = @"
-class A
-{
-    void M()
-    {
-        int x = 0;
-    }
-}";
-
-            using var workspace = EditorTestWorkspace.CreateCSharp(source,
-                composition: s_editorFeaturesCompositionWithMockDiagnosticUpdateSourceRegistrationService.AddParts(typeof(TestDocumentTrackingService)));
-            Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(
-                workspace.CurrentSolution.Options.WithChangedOption(new OptionKey(DiagnosticOptionsStorage.PullDiagnosticsFeatureFlag), false))));
-
-            var analyzer = new CancellationTestAnalyzer(actionKind);
-            var analyzerReference = new AnalyzerImageReference(ImmutableArray.Create<DiagnosticAnalyzer>(analyzer));
-            workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences(new[] { analyzerReference }));
-
-            var project = workspace.CurrentSolution.Projects.Single();
-            var document = project.Documents.Single();
-
-            Assert.IsType<MockDiagnosticUpdateSourceRegistrationService>(workspace.GetService<IDiagnosticUpdateSourceRegistrationService>());
-            var service = Assert.IsType<DiagnosticAnalyzerService>(workspace.GetService<IDiagnosticAnalyzerService>());
-            var globalOptions = workspace.GetService<IGlobalOptionService>();
-
-            DiagnosticData diagnostic = null;
-            service.DiagnosticsUpdated += (s, eCollection) =>
-            {
-                foreach (var e in eCollection)
-                {
-                    var diagnostics = e.Diagnostics;
-                    if (diagnostics.IsEmpty)
-                    {
-                        continue;
-                    }
-
-                    Assert.Null(diagnostic);
-                    diagnostic = Assert.Single(diagnostics);
-                }
-            };
-
-            var incrementalAnalyzer = service.CreateIncrementalAnalyzer(workspace);
-
-            OpenDocumentAndMakeActive(document, workspace);
-
-            // First invoke analysis with cancellation token, and verify canceled compilation and no reported diagnostics.
-            Assert.Empty(analyzer.CanceledCompilations);
-            try
-            {
-                await incrementalAnalyzer.ForceAnalyzeProjectAsync(project, analyzer.CancellationToken);
-
-                throw ExceptionUtilities.Unreachable();
-            }
-            catch (OperationCanceledException ex) when (ex.CancellationToken == analyzer.CancellationToken)
-            {
-            }
-
-            Assert.Single(analyzer.CanceledCompilations);
-            Assert.Null(diagnostic);
-
-            // Then invoke analysis without cancellation token, and verify non-cancelled diagnostic.
-            await incrementalAnalyzer.ForceAnalyzeProjectAsync(project, CancellationToken.None);
-
-            await ((AsynchronousOperationListener)service.Listener).ExpeditedWaitAsync();
-
-            Assert.True(diagnostic != null);
-            Assert.Equal(CancellationTestAnalyzer.DiagnosticId, diagnostic.Id);
-        }
-
         [Theory, CombinatorialData]
         [WorkItem("https://github.com/dotnet/roslyn/issues/49698")]
         internal async Task TestOnlyRequiredAnalyzerExecutedDuringDiagnosticComputation(bool documentAnalysis)

From a615340582ef9f68734c877b78d37730736f3404 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Fri, 15 Mar 2024 12:14:56 +0100
Subject: [PATCH 080/170] Update dependencies from
 https://github.com/dotnet/source-build-reference-packages build 20240311.2
 (#72502)

Microsoft.SourceBuild.Intermediate.source-build-reference-packages
 From Version 9.0.0-alpha.1.24155.1 -> To Version 9.0.0-alpha.1.24161.2

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
---
 eng/Version.Details.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index d281fce2ac599..ee8c8d0b23530 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -8,9 +8,9 @@
       <SourceBuild RepoName="source-build-externals" ManagedOnly="true" />
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-reference-packages" Version="9.0.0-alpha.1.24155.1">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-reference-packages" Version="9.0.0-alpha.1.24161.2">
       <Uri>https://github.com/dotnet/source-build-reference-packages</Uri>
-      <Sha>768378e775fc5ddc99d41f2c4d1c78182f326ea7</Sha>
+      <Sha>8d6e9cf10f64ff8fc02e434b516f6ca87c4b7215</Sha>
       <SourceBuild RepoName="source-build-reference-packages" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="System.CommandLine" Version="2.0.0-beta4.24126.1">

From ff27b0876a5b38d1bcc503ae763f81e5318ff18a Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Fri, 15 Mar 2024 12:16:08 +0100
Subject: [PATCH 081/170] Update dependencies from
 https://github.com/dotnet/arcade build 20240311.1 (#72503)

Microsoft.SourceBuild.Intermediate.arcade , Microsoft.DotNet.Arcade.Sdk , Microsoft.DotNet.Helix.Sdk
 From Version 8.0.0-beta.24158.4 -> To Version 8.0.0-beta.24161.1

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
---
 eng/Version.Details.xml | 12 ++++++------
 global.json             |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index ee8c8d0b23530..fbe4b4f6b8f44 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -110,14 +110,14 @@
     </Dependency>
   </ProductDependencies>
   <ToolsetDependencies>
-    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="8.0.0-beta.24158.4">
+    <Dependency Name="Microsoft.DotNet.Arcade.Sdk" Version="8.0.0-beta.24161.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>052a4b9e7a9bdb9744c86c05665f1b46e4d59b15</Sha>
+      <Sha>5c3fdd3b5aaaa32b24383ec12a60b37ebff13079</Sha>
     </Dependency>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.arcade" Version="8.0.0-beta.24158.4">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.arcade" Version="8.0.0-beta.24161.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>052a4b9e7a9bdb9744c86c05665f1b46e4d59b15</Sha>
+      <Sha>5c3fdd3b5aaaa32b24383ec12a60b37ebff13079</Sha>
       <SourceBuild RepoName="arcade" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.DotNet.XliffTasks" Version="1.0.0-beta.23475.1" CoherentParentDependency="Microsoft.DotNet.Arcade.Sdk">
@@ -144,9 +144,9 @@
       <Uri>https://github.com/dotnet/roslyn</Uri>
       <Sha>5d10d428050c0d6afef30a072c4ae68776621877</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="8.0.0-beta.24158.4">
+    <Dependency Name="Microsoft.DotNet.Helix.Sdk" Version="8.0.0-beta.24161.1">
       <Uri>https://github.com/dotnet/arcade</Uri>
-      <Sha>052a4b9e7a9bdb9744c86c05665f1b46e4d59b15</Sha>
+      <Sha>5c3fdd3b5aaaa32b24383ec12a60b37ebff13079</Sha>
     </Dependency>
     <Dependency Name="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0-preview.23468.1">
       <Uri>https://github.com/dotnet/roslyn-analyzers</Uri>
diff --git a/global.json b/global.json
index ff6f775d56486..f323d2b0bb65e 100644
--- a/global.json
+++ b/global.json
@@ -12,8 +12,8 @@
     "xcopy-msbuild": "17.8.1-2"
   },
   "msbuild-sdks": {
-    "Microsoft.DotNet.Arcade.Sdk": "8.0.0-beta.24158.4",
-    "Microsoft.DotNet.Helix.Sdk": "8.0.0-beta.24158.4",
+    "Microsoft.DotNet.Arcade.Sdk": "8.0.0-beta.24161.1",
+    "Microsoft.DotNet.Helix.Sdk": "8.0.0-beta.24161.1",
     "Microsoft.Build.Traversal": "3.4.0"
   }
 }

From dea4c7f73929154b5d2f43782417f343e1e00dbb Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <Maryam.Ariyan@microsoft.com>
Date: Fri, 15 Mar 2024 09:20:32 -0700
Subject: [PATCH 082/170] Fix failing tests

---
 .../TelemetryReporterTests.cs                               | 2 +-
 .../Utilities/AbstractLanguageServerHostTests.cs            | 3 ++-
 .../Utilities/LanguageServerTestComposition.cs              | 4 ++--
 .../WorkspaceProjectFactoryServiceTests.cs                  | 6 +++++-
 4 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/TelemetryReporterTests.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/TelemetryReporterTests.cs
index b23ed5d2a4d0f..25f175456269d 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/TelemetryReporterTests.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/TelemetryReporterTests.cs
@@ -18,7 +18,7 @@ public TelemetryReporterTests(ITestOutputHelper testOutputHelper)
 
     private async Task<ITelemetryReporter> CreateReporterAsync()
     {
-        var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync(TestOutputLogger.Factory, includeDevKitComponents: true);
+        var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync(TestOutputLogger.Factory, includeDevKitComponents: true, out var _);
 
         var reporter = exportProvider.GetExport<ITelemetryReporter>().Value;
         Assert.NotNull(reporter);
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs
index 628c98933de55..49c5e48bb623f 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/AbstractLanguageServerHostTests.cs
@@ -33,7 +33,8 @@ protected sealed class TestLspServer : IAsyncDisposable
 
         internal static async Task<TestLspServer> CreateAsync(ClientCapabilities clientCapabilities, TestOutputLogger logger, bool includeDevKitComponents = true)
         {
-            var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync(logger.Factory, includeDevKitComponents);
+            var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync(
+                logger.Factory, includeDevKitComponents, out var _);
             var testLspServer = new TestLspServer(exportProvider, logger);
             var initializeResponse = await testLspServer.ExecuteRequestAsync<InitializeParams, InitializeResult>(Methods.InitializeName, new InitializeParams { Capabilities = clientCapabilities }, CancellationToken.None);
             Assert.NotNull(initializeResponse?.Capabilities);
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
index fab6370f9f30d..785846c6cbd4b 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs
@@ -22,10 +22,10 @@ internal sealed class LanguageServerTestComposition
     private static string GetDevKitExtensionPath()
         => Path.Combine(AppContext.BaseDirectory, DevKitExtensionSubdirectory, DevKitAssemblyFileName);
 
-    public static Task<ExportProvider> CreateExportProviderAsync(ILoggerFactory loggerFactory, bool includeDevKitComponents)
+    public static Task<ExportProvider> CreateExportProviderAsync(ILoggerFactory loggerFactory, bool includeDevKitComponents, out ServerConfiguration serverConfiguration)
     {
         var devKitDependencyPath = includeDevKitComponents ? GetDevKitExtensionPath() : null;
-        var serverConfiguration = new ServerConfiguration(LaunchDebugger: false,
+        serverConfiguration = new ServerConfiguration(LaunchDebugger: false,
             MinimumLogLevel: LogLevel.Trace,
             StarredCompletionsPath: null,
             TelemetryLevel: null,
diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/WorkspaceProjectFactoryServiceTests.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/WorkspaceProjectFactoryServiceTests.cs
index 2b5aac043fcc2..5a896b036b216 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/WorkspaceProjectFactoryServiceTests.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/WorkspaceProjectFactoryServiceTests.cs
@@ -15,7 +15,11 @@ public class WorkspaceProjectFactoryServiceTests
     [Fact]
     public async Task CreateProjectAndBatch()
     {
-        using var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync(new LoggerFactory(), includeDevKitComponents: false);
+        using var exportProvider = await LanguageServerTestComposition.CreateExportProviderAsync(
+            new LoggerFactory(), includeDevKitComponents: false, out var serverConfiguration);
+
+        exportProvider.GetExportedValue<ServerConfigurationFactory>()
+            .InitializeConfiguration(serverConfiguration);
         await exportProvider.GetExportedValue<ServiceBrokerFactory>().CreateAsync();
 
         var workspaceFactory = exportProvider.GetExportedValue<LanguageServerWorkspaceFactory>();

From b63b5c57495d19cd2ce295ecd002fbcdff1a24fe Mon Sep 17 00:00:00 2001
From: Newrad0603 <andrewsarratori@gmail.com>
Date: Fri, 15 Mar 2024 12:29:14 -0400
Subject: [PATCH 083/170] Fix the incorrect usage of color tokens in the
 RenameFlyout and DisposableToolTip. The change makes those controls use
 DynamicResources for the color tokens rather than using the VSColorTheme
 helper or directly querying the Application-level resource dictionary. The
 change also removes an invalid set of
 ImageThemingUtilities.ImageBackgroundColor. (#72538)

---
 .../UI/Adornment/RenameFlyout.xaml            | 45 ++++++++++---------
 .../UI/Adornment/RenameFlyout.xaml.cs         | 20 +--------
 .../QuickInfo/ContentControlService.cs        | 16 ++++---
 3 files changed, 33 insertions(+), 48 deletions(-)

diff --git a/src/EditorFeatures/Core.Wpf/InlineRename/UI/Adornment/RenameFlyout.xaml b/src/EditorFeatures/Core.Wpf/InlineRename/UI/Adornment/RenameFlyout.xaml
index 808ffca7525f9..cb01f2428b6ef 100644
--- a/src/EditorFeatures/Core.Wpf/InlineRename/UI/Adornment/RenameFlyout.xaml
+++ b/src/EditorFeatures/Core.Wpf/InlineRename/UI/Adornment/RenameFlyout.xaml
@@ -2,14 +2,14 @@
              x:ClassModifier="internal"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
-             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:rename="clr-namespace:Microsoft.CodeAnalysis.Editor.Implementation.InlineRename"
              xmlns:imaging="clr-namespace:Microsoft.VisualStudio.Imaging;assembly=Microsoft.VisualStudio.Imaging"
              xmlns:imagecatalog="clr-namespace:Microsoft.VisualStudio.Imaging;assembly=Microsoft.VisualStudio.ImageCatalog"
-             xmlns:imageutils="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Imaging"
              xmlns:utils="clr-namespace:Microsoft.CodeAnalysis.Utilities"
-             mc:Ignorable="d" 
+             xmlns:vsui="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Shell.15.0"
+             mc:Ignorable="d"
              d:DesignHeight="450" d:DesignWidth="800"
              MinWidth="200"
              KeyDown="Adornment_KeyDown"
@@ -28,7 +28,9 @@
         </ResourceDictionary>
     </UserControl.Resources>
 
-    <Border 
+    <Border
+        Background="{DynamicResource {x:Static vsui:EnvironmentColors.ToolWindowBackgroundBrushKey}}"
+        BorderBrush="{DynamicResource {x:Static vsui:EnvironmentColors.ToolWindowBorderBrushKey}}"
         BorderThickness="1"
         x:Name="Outline">
         <StackPanel x:Name="MainPanel" Orientation="Vertical" Margin="5" >
@@ -44,18 +46,17 @@
                     HorizontalAlignment="Stretch"/>
 
                 <!-- Expand/Collapse button and glyph -->
-                <Button 
-                    x:Name="ToggleExpandButton" 
-                    Grid.Column="1" 
-                    Click="ToggleExpand" 
-                    Background="Transparent"
-                    imageutils:ImageThemingUtilities.ImageBackgroundColor="{Binding Path=Parent.Background, RelativeSource={RelativeSource Self}, Converter={StaticResource BrushToColorConverter}}">
+                <Button
+                    x:Name="ToggleExpandButton"
+                    Grid.Column="1"
+                    Click="ToggleExpand"
+                    Background="Transparent">
                     <Button.Style>
                         <Style TargetType="Button">
                             <Setter Property="Template">
                                 <Setter.Value>
                                     <ControlTemplate TargetType="Button">
-                                        <Border Name="border" 
+                                        <Border Name="border"
                                         BorderThickness="1"
                                         Background="{TemplateBinding Background}">
                                             <ContentPresenter HorizontalAlignment="Center" VerticalAlignment="Center" />
@@ -93,8 +94,8 @@
                 <TextBlock Grid.Column="1" Text="{Binding StatusText}" />
             </Grid>
 
-            <TextBlock 
-                Text="{Binding SearchText}" 
+            <TextBlock
+                Text="{Binding SearchText}"
                 Visibility="{Binding ShowSearchText, Converter={StaticResource BooleanToVisibilityConverter}}"
                 FontWeight="Light"
                 Margin="0,0,0,5" />
@@ -104,20 +105,20 @@
                       Name="OverloadsCheckbox" Visibility="{Binding IsRenameOverloadsVisible, Converter={StaticResource BooleanToVisibilityConverter}, Mode=OneWay}" IsEnabled="{Binding IsRenameOverloadsEditable}" />
                 <CheckBox Name="CommentsCheckbox" Content="{Binding ElementName=control, Path=SearchInComments}" Margin="0,5,0,0" IsChecked="{Binding Path=RenameInCommentsFlag, Mode=TwoWay}" />
                 <CheckBox Name="StringsCheckbox" Content="{Binding ElementName=control, Path=SearchInStrings}" Margin="0,5,0,0" IsChecked="{Binding Path=RenameInStringsFlag, Mode=TwoWay}" />
-                <CheckBox Name="FileRenameCheckbox" 
-                    Content="{Binding Path=FileRenameString}" 
+                <CheckBox Name="FileRenameCheckbox"
+                    Content="{Binding Path=FileRenameString}"
                     Margin="0,5,0,0"
-                    IsChecked="{Binding Path=RenameFileFlag, Mode=TwoWay}" 
-                    IsEnabled="{Binding Path=AllowFileRename, Mode=OneWay}" 
+                    IsChecked="{Binding Path=RenameFileFlag, Mode=TwoWay}"
+                    IsEnabled="{Binding Path=AllowFileRename, Mode=OneWay}"
                     Visibility="{Binding Path=ShowFileRename, Converter={StaticResource BooleanToVisibilityConverter}, Mode=OneWay}"/>
             </StackPanel>
 
-            <TextBlock 
+            <TextBlock
                 x:Name="SubmitTextBlock"
-                Text="{Binding ElementName=control, Path=SubmitText}" 
-                Margin="5, 5, 0, 0" 
+                Text="{Binding ElementName=control, Path=SubmitText}"
+                Margin="5, 5, 0, 0"
                 FontStyle="Italic"
                 />
-    </StackPanel>
+        </StackPanel>
     </Border>
 </rename:InlineRenameAdornment>
diff --git a/src/EditorFeatures/Core.Wpf/InlineRename/UI/Adornment/RenameFlyout.xaml.cs b/src/EditorFeatures/Core.Wpf/InlineRename/UI/Adornment/RenameFlyout.xaml.cs
index 79b6ddb5931a9..62884e0a636e2 100644
--- a/src/EditorFeatures/Core.Wpf/InlineRename/UI/Adornment/RenameFlyout.xaml.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineRename/UI/Adornment/RenameFlyout.xaml.cs
@@ -80,10 +80,7 @@ public RenameFlyout(
                 MainPanel.Children.Insert(index + 1, smartRenameControl);
             }
 
-            RefreshColors();
-
             _editorFormatMap = editorFormatMapService.GetEditorFormatMap("text");
-            _editorFormatMap.FormatMappingChanged += FormatMappingChanged;
 
             // Dismiss any current tooltips. Note that this does not disable tooltips
             // from showing up again, so if a user has the mouse unmoved another
@@ -95,20 +92,6 @@ public RenameFlyout(
 
         internal IRenameUserInput RenameUserInput { get; }
 
-        private void FormatMappingChanged(object sender, FormatItemsEventArgs e)
-        {
-            RefreshColors();
-        }
-
-        private void RefreshColors()
-        {
-            if (_wpfThemeService is not null)
-            {
-                Outline.BorderBrush = new SolidColorBrush(_wpfThemeService.GetThemeColor(EnvironmentColors.AccentBorderColorKey));
-                Background = new SolidColorBrush(_wpfThemeService.GetThemeColor(EnvironmentColors.ToolWindowBackgroundColorKey));
-            }
-        }
-
         private async Task DismissToolTipsAsync()
         {
             var infoSession = _asyncQuickInfoBroker.GetSession(_textView);
@@ -178,7 +161,6 @@ public override void Dispose()
             _textView.LayoutChanged -= TextView_LayoutChanged;
             _textView.ViewportHeightChanged -= TextView_ViewPortChanged;
             _textView.ViewportWidthChanged -= TextView_ViewPortChanged;
-            _editorFormatMap.FormatMappingChanged -= FormatMappingChanged;
 
             // Restore focus back to the textview
             _textView.VisualElement.Focus();
@@ -205,7 +187,7 @@ private void Adornment_KeyDown(object sender, KeyEventArgs e)
                     break;
 
                 case Key.Tab:
-                    // We don't want tab to lose focus for the adornment, so manually 
+                    // We don't want tab to lose focus for the adornment, so manually
                     // loop focus back to the first item that is focusable.
                     var lastItem = _viewModel.IsExpanded
                         ? FileRenameCheckbox
diff --git a/src/EditorFeatures/Core.Wpf/QuickInfo/ContentControlService.cs b/src/EditorFeatures/Core.Wpf/QuickInfo/ContentControlService.cs
index 7d882d8b6d865..2472a02b3a58c 100644
--- a/src/EditorFeatures/Core.Wpf/QuickInfo/ContentControlService.cs
+++ b/src/EditorFeatures/Core.Wpf/QuickInfo/ContentControlService.cs
@@ -59,13 +59,14 @@ public DisposableToolTip CreateDisposableToolTip(Document document, ITextBuffer
             // Create the actual tooltip around the region of that text buffer we want to show.
             var toolTip = new ToolTip
             {
-                Content = control,
-                Background = (Brush)Application.Current.Resources[backgroundResourceKey]
+                Content = control
             };
 
-            // Create a preview workspace for this text buffer and open it's corresponding 
-            // document. 
-            // 
+            toolTip.SetResourceReference(Control.BackgroundProperty, backgroundResourceKey);
+
+            // Create a preview workspace for this text buffer and open it's corresponding
+            // document.
+            //
             // our underlying preview tagger and mechanism to attach tagger to associated buffer of
             // opened document will light up automatically
             var workspace = new PreviewWorkspace(document.Project.Solution);
@@ -81,10 +82,11 @@ public DisposableToolTip CreateDisposableToolTip(ITextBuffer textBuffer, object
             // Create the actual tooltip around the region of that text buffer we want to show.
             var toolTip = new ToolTip
             {
-                Content = control,
-                Background = (Brush)Application.Current.Resources[backgroundResourceKey]
+                Content = control
             };
 
+            toolTip.SetResourceReference(Control.BackgroundProperty, backgroundResourceKey);
+
             // we have stand alone view that is not associated with roslyn solution
             return new DisposableToolTip(toolTip, workspaceOpt: null);
         }

From 8d932e955287291e152822598e3e2cf58deff039 Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Fri, 15 Mar 2024 09:51:57 -0700
Subject: [PATCH 084/170] Bind child expressions within bad stackalloc
 expression to natural type (#72454)

---
 .../Portable/Binder/Binder_Expressions.cs     |  2 +-
 .../Semantics/StackAllocInitializerTests.cs   | 92 +++++++++++++++++++
 2 files changed, 93 insertions(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index fbb120de133e8..c577341e48531 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -4063,7 +4063,7 @@ private BoundExpression BindStackAllocArrayCreationExpression(
                     {
                         if (size.Kind() != SyntaxKind.OmittedArraySizeExpression)
                         {
-                            builder.Add(BindExpression(size, BindingDiagnosticBag.Discarded));
+                            builder.Add(BindToTypeForErrorRecovery(BindExpression(size, BindingDiagnosticBag.Discarded)));
                         }
                     }
                 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/StackAllocInitializerTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/StackAllocInitializerTests.cs
index bcb6566db7d19..d96e6abf25f3b 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/StackAllocInitializerTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/StackAllocInitializerTests.cs
@@ -2677,5 +2677,97 @@ public void Method1()
 
             Assert.Null(model.GetDeclaredSymbol(@stackalloc));
         }
+
+        [WorkItem("https://github.com/dotnet/roslyn/issues/72448")]
+        [Fact]
+        public void UnconvertedExpression_01()
+        {
+            string source = """
+                stackalloc X[new(), new()];
+                """;
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.VerifyDiagnostics(
+                // (1,1): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
+                // stackalloc X[new(), new()];
+                Diagnostic(ErrorCode.ERR_IllegalStatement, "stackalloc X[new(), new()]").WithLocation(1, 1),
+                // (1,12): error CS0246: The type or namespace name 'X' could not be found (are you missing a using directive or an assembly reference?)
+                // stackalloc X[new(), new()];
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "X").WithArguments("X").WithLocation(1, 12),
+                // (1,12): error CS1575: A stackalloc expression requires [] after type
+                // stackalloc X[new(), new()];
+                Diagnostic(ErrorCode.ERR_BadStackAllocExpr, "X[new(), new()]").WithLocation(1, 12));
+
+            var tree = comp.SyntaxTrees[0];
+            var model = comp.GetSemanticModel(tree);
+            var operation = model.GetOperation(tree.GetRoot());
+            var actualOperationTree = GetOperationTreeForTest(comp, operation);
+            OperationTreeVerifier.Verify("""
+                IMethodBodyOperation (OperationKind.MethodBody, Type: null, IsInvalid) (Syntax: 'stackalloc  ... (), new()];')
+                  BlockBody:
+                    IBlockOperation (1 statements) (OperationKind.Block, Type: null, IsInvalid, IsImplicit) (Syntax: 'stackalloc  ... (), new()];')
+                      IExpressionStatementOperation (OperationKind.ExpressionStatement, Type: null, IsInvalid) (Syntax: 'stackalloc  ... (), new()];')
+                        Expression:
+                          IInvalidOperation (OperationKind.Invalid, Type: X*, IsInvalid) (Syntax: 'stackalloc  ... w(), new()]')
+                            Children(2):
+                                IInvalidOperation (OperationKind.Invalid, Type: ?, IsInvalid) (Syntax: 'new()')
+                                  Children(0)
+                                IInvalidOperation (OperationKind.Invalid, Type: ?, IsInvalid) (Syntax: 'new()')
+                                  Children(0)
+                  ExpressionBody:
+                    null
+                """,
+                actualOperationTree);
+        }
+
+        [WorkItem("https://github.com/dotnet/roslyn/issues/72448")]
+        [Fact]
+        public void UnconvertedExpression_02()
+        {
+            string source = """
+                object x;
+                stackalloc X[0, new(out x)];
+                object y = x;
+                """;
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.VerifyDiagnostics(
+                // (2,1): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
+                // stackalloc X[0, new(out x)];
+                Diagnostic(ErrorCode.ERR_IllegalStatement, "stackalloc X[0, new(out x)]").WithLocation(2, 1),
+                // (2,12): error CS0246: The type or namespace name 'X' could not be found (are you missing a using directive or an assembly reference?)
+                // stackalloc X[0, new(out x)];
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "X").WithArguments("X").WithLocation(2, 12),
+                // (2,12): error CS1575: A stackalloc expression requires [] after type
+                // stackalloc X[0, new(out x)];
+                Diagnostic(ErrorCode.ERR_BadStackAllocExpr, "X[0, new(out x)]").WithLocation(2, 12),
+                // (2,25): error CS0165: Use of unassigned local variable 'x'
+                // stackalloc X[0, new(out x)];
+                Diagnostic(ErrorCode.ERR_UseDefViolation, "x").WithArguments("x").WithLocation(2, 25));
+        }
+
+        [WorkItem("https://github.com/dotnet/roslyn/issues/72448")]
+        [Theory]
+        [InlineData("default")]
+        [InlineData("(default, 1)")]
+        [InlineData("[]")]
+        [InlineData("$\"str\"")]
+        [InlineData("args.Length > 0 ? default : default")]
+        [InlineData("args.Length > 0 switch { true => default, false => default }")]
+        public void UnconvertedExpression_03(string expr)
+        {
+            string source = $$"""
+                stackalloc X[0, {{expr}}];
+                """;
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.VerifyDiagnostics(
+                // (1,1): error CS0201: Only assignment, call, increment, decrement, await, and new object expressions can be used as a statement
+                // stackalloc X[0, default];
+                Diagnostic(ErrorCode.ERR_IllegalStatement, $"stackalloc X[0, {expr}]").WithLocation(1, 1),
+                // (1,12): error CS0246: The type or namespace name 'X' could not be found (are you missing a using directive or an assembly reference?)
+                // stackalloc X[0, default];
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "X").WithArguments("X").WithLocation(1, 12),
+                // (1,12): error CS1575: A stackalloc expression requires [] after type
+                // stackalloc X[0, default];
+                Diagnostic(ErrorCode.ERR_BadStackAllocExpr, $"X[0, {expr}]").WithLocation(1, 12));
+        }
     }
 }

From 2ab1ea91720646501ea42941ffe6b88bebd30d01 Mon Sep 17 00:00:00 2001
From: Marco Goertz <mgoertz@microsoft.com>
Date: Fri, 15 Mar 2024 09:58:15 -0700
Subject: [PATCH 085/170] ExternalAccess.Xaml fixes - Replaced incompatible
 `CreateHoverResultAsync` with `CreateMarkdownContent` - Fixed XAML
 `DesciptionService` to show code examples in proper code blocks

---
 .../Xaml/External/ConversionHelpers.cs        | 23 ++++++++++++-------
 .../Xaml/Internal/DescriptionService.cs       | 15 +++++++++++-
 .../Xaml/InternalAPI.Unshipped.txt            |  1 +
 3 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/src/Tools/ExternalAccess/Xaml/External/ConversionHelpers.cs b/src/Tools/ExternalAccess/Xaml/External/ConversionHelpers.cs
index bf11bd912e549..e3b37c1663b49 100644
--- a/src/Tools/ExternalAccess/Xaml/External/ConversionHelpers.cs
+++ b/src/Tools/ExternalAccess/Xaml/External/ConversionHelpers.cs
@@ -3,10 +3,9 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Collections.Immutable;
+using System.Linq;
 using Microsoft.CodeAnalysis.LanguageServer;
-using Microsoft.CodeAnalysis.LanguageServer.Handler;
 using Microsoft.CodeAnalysis.QuickInfo;
 using LSP = Roslyn.LanguageServer.Protocol;
 
@@ -17,9 +16,17 @@ internal static class ConversionHelpers
     public static Uri CreateAbsoluteUri(string absolutePath)
         => ProtocolConversions.CreateAbsoluteUri(absolutePath);
 
-    /// <summary>
-    /// Helper to create <see cref="LSP.Hover"/> from <see cref="QuickInfoItem"/>.
-    /// </summary>
-    public static Task<LSP.Hover> CreateHoverResultAsync(TextDocument document, QuickInfoItem info, XamlRequestContext context, CancellationToken cancellationToken)
-        => DefaultLspHoverResultCreationService.CreateDefaultHoverAsync(document, info, context.ClientCapabilities, cancellationToken);
+    public static (string content, bool isMarkdown) CreateMarkdownContent(TextDocument document, QuickInfoItem info, XamlRequestContext context)
+    {
+        var clientSupportsMarkdown = context.ClientCapabilities?.TextDocument?.Hover?.ContentFormat?.Contains(LSP.MarkupKind.Markdown) == true;
+
+        // Insert line breaks in between sections to ensure we get double spacing between sections.
+        var tags = info.Sections
+            .SelectMany(section => section.TaggedParts.Add(new TaggedText(TextTags.LineBreak, Environment.NewLine)))
+            .ToImmutableArray();
+
+        var language = document.Project.Language;
+        var markupContent = ProtocolConversions.GetDocumentationMarkupContent(tags, language, clientSupportsMarkdown);
+        return (markupContent.Value, markupContent.Kind == LSP.MarkupKind.Markdown);
+    }
 }
diff --git a/src/Tools/ExternalAccess/Xaml/Internal/DescriptionService.cs b/src/Tools/ExternalAccess/Xaml/Internal/DescriptionService.cs
index 7181a90f0ff16..4b0a3ff24eab8 100644
--- a/src/Tools/ExternalAccess/Xaml/Internal/DescriptionService.cs
+++ b/src/Tools/ExternalAccess/Xaml/Internal/DescriptionService.cs
@@ -74,7 +74,20 @@ public async Task<IEnumerable<TaggedText>> GetDescriptionAsync(ISymbol symbol, P
                 builder.AddLineBreak();
             }
 
-            builder.AddRange(section.TaggedParts);
+            foreach (var part in section.TaggedParts)
+            {
+                if (part.Style == (TaggedTextStyle.Code | TaggedTextStyle.PreserveWhitespace) &&
+                    builder.LastOrDefault().Tag != TextTags.CodeBlockStart)
+                {
+                    builder.Add(new TaggedText(TextTags.CodeBlockStart, string.Empty));
+                    builder.Add(part);
+                    builder.Add(new TaggedText(TextTags.CodeBlockEnd, string.Empty));
+                }
+                else
+                {
+                    builder.Add(part);
+                }
+            }
         }
 
         return builder.ToImmutableArray();
diff --git a/src/Tools/ExternalAccess/Xaml/InternalAPI.Unshipped.txt b/src/Tools/ExternalAccess/Xaml/InternalAPI.Unshipped.txt
index e947cc2b91b1e..fa4854933b7d1 100644
--- a/src/Tools/ExternalAccess/Xaml/InternalAPI.Unshipped.txt
+++ b/src/Tools/ExternalAccess/Xaml/InternalAPI.Unshipped.txt
@@ -69,6 +69,7 @@ Microsoft.CodeAnalysis.ExternalAccess.Xaml.XamlRequestHandlerFactoryBase<TReques
 Microsoft.CodeAnalysis.ExternalAccess.Xaml.XamlRequestHandlerFactoryBase<TRequest, TResponse>.XamlRequestHandlerFactoryBase(Microsoft.CodeAnalysis.ExternalAccess.Xaml.IXamlRequestHandler<TRequest, TResponse>? xamlRequestHandler) -> void
 static Microsoft.CodeAnalysis.ExternalAccess.Xaml.ConversionHelpers.CreateAbsoluteUri(string! absolutePath) -> System.Uri!
 static Microsoft.CodeAnalysis.ExternalAccess.Xaml.ConversionHelpers.CreateHoverResultAsync(Microsoft.CodeAnalysis.TextDocument! document, Microsoft.CodeAnalysis.QuickInfo.QuickInfoItem! info, Microsoft.CodeAnalysis.ExternalAccess.Xaml.XamlRequestContext context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<Roslyn.LanguageServer.Protocol.Hover!>!
+static Microsoft.CodeAnalysis.ExternalAccess.Xaml.ConversionHelpers.CreateMarkdownContent(Microsoft.CodeAnalysis.TextDocument! document, Microsoft.CodeAnalysis.QuickInfo.QuickInfoItem! info, Microsoft.CodeAnalysis.ExternalAccess.Xaml.XamlRequestContext context) -> (string! content, bool isMarkdown)
 static Microsoft.CodeAnalysis.ExternalAccess.Xaml.ResolveDataConversions.FromCachedResolveData(object? lspData, Microsoft.CodeAnalysis.LanguageServer.Handler.ResolveDataCache! resolveDataCache) -> (object? data, System.Uri? uri)
 static Microsoft.CodeAnalysis.ExternalAccess.Xaml.ResolveDataConversions.FromResolveData(object? requestData) -> (object? data, System.Uri? uri)
 static Microsoft.CodeAnalysis.ExternalAccess.Xaml.ResolveDataConversions.ToCachedResolveData(object! data, System.Uri! uri, Microsoft.CodeAnalysis.LanguageServer.Handler.ResolveDataCache! resolveDataCache) -> object!

From 70a21ef44edbbd75aec8658e7069c2946e984f6c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Fri, 15 Mar 2024 10:29:31 -0700
Subject: [PATCH 086/170] Remove notification on diagnostic updates

---
 ....SingleDiagnosticKindPullTaggerProvider.cs | 15 ++++--
 .../AbstractDiagnosticsTaggerProvider.cs      | 16 +-----
 .../InlineDiagnosticsTaggerProvider.cs        |  2 -
 ...ntSources.DiagnosticsChangedEventSource.cs | 52 -------------------
 .../EventSources/TaggerEventSources.cs        |  3 --
 5 files changed, 13 insertions(+), 75 deletions(-)
 delete mode 100644 src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.DiagnosticsChangedEventSource.cs

diff --git a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs
index 3016dfbede679..5e7f9c5b5cae9 100644
--- a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.SingleDiagnosticKindPullTaggerProvider.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Preview;
+using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.Tagging;
 using Microsoft.CodeAnalysis.ErrorReporting;
@@ -38,14 +39,12 @@ private sealed class SingleDiagnosticKindPullTaggerProvider(
         AbstractDiagnosticsTaggerProvider<TTag> callback,
         DiagnosticKind diagnosticKind,
         IThreadingContext threadingContext,
-        IDiagnosticService diagnosticService,
         IDiagnosticAnalyzerService analyzerService,
         IGlobalOptionService globalOptions,
         ITextBufferVisibilityTracker? visibilityTracker,
         IAsynchronousOperationListener listener) : AsynchronousTaggerProvider<TTag>(threadingContext, globalOptions, visibilityTracker, listener)
     {
         private readonly DiagnosticKind _diagnosticKind = diagnosticKind;
-        private readonly IDiagnosticService _diagnosticService = diagnosticService;
         private readonly IDiagnosticAnalyzerService _analyzerService = analyzerService;
 
         // The following three fields are used to help calculate diagnostic performance for syntax errors upon file open.
@@ -80,7 +79,17 @@ protected sealed override bool TagEquals(TTag tag1, TTag tag2)
             => _callback.TagEquals(tag1, tag2);
 
         protected sealed override ITaggerEventSource CreateEventSource(ITextView? textView, ITextBuffer subjectBuffer)
-            => CreateEventSourceWorker(subjectBuffer, _diagnosticService);
+        {
+            // OnTextChanged is added for diagnostics in source generated files: it's possible that the analyzer driver
+            // executed on content which was produced by a source generator but is not yet reflected in an open text
+            // buffer for that generated file. In this case, we need to update the tags after the buffer updates (which
+            // triggers a text changed event) to ensure diagnostics are positioned correctly.
+            return TaggerEventSources.Compose(
+                TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer),
+                TaggerEventSources.OnWorkspaceRegistrationChanged(subjectBuffer),
+                TaggerEventSources.OnWorkspaceChanged(subjectBuffer, this.AsyncListener),
+                TaggerEventSources.OnTextChanged(subjectBuffer));
+        }
 
         protected sealed override Task ProduceTagsAsync(
             TaggerContext<TTag> context, DocumentSnapshotSpan spanToTag, int? caretPosition, CancellationToken cancellationToken)
diff --git a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.cs b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.cs
index bcc13f909297d..406c613e58090 100644
--- a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/AbstractDiagnosticsTaggerProvider.cs
@@ -35,7 +35,6 @@ internal abstract partial class AbstractDiagnosticsTaggerProvider<TTag> : ITagge
 
     public AbstractDiagnosticsTaggerProvider(
         IThreadingContext threadingContext,
-        IDiagnosticService diagnosticService,
         IDiagnosticAnalyzerService analyzerService,
         IGlobalOptionService globalOptions,
         ITextBufferVisibilityTracker? visibilityTracker,
@@ -54,7 +53,7 @@ public AbstractDiagnosticsTaggerProvider(
         return;
 
         SingleDiagnosticKindPullTaggerProvider CreateDiagnosticsTaggerProvider(DiagnosticKind diagnosticKind)
-            => new(this, diagnosticKind, threadingContext, diagnosticService, analyzerService, globalOptions, visibilityTracker, listener);
+            => new(this, diagnosticKind, threadingContext, analyzerService, globalOptions, visibilityTracker, listener);
     }
 
     // Functionality for subclasses to control how this diagnostic tagging operates.  All the individual
@@ -99,19 +98,6 @@ protected virtual ImmutableArray<DiagnosticDataLocation> GetLocationsToTag(Diagn
         return genericTagger;
     }
 
-    private static ITaggerEventSource CreateEventSourceWorker(ITextBuffer subjectBuffer, IDiagnosticService diagnosticService)
-    {
-        // OnTextChanged is added for diagnostics in source generated files: it's possible that the analyzer driver
-        // executed on content which was produced by a source generator but is not yet reflected in an open text
-        // buffer for that generated file. In this case, we need to update the tags after the buffer updates (which
-        // triggers a text changed event) to ensure diagnostics are positioned correctly.
-        return TaggerEventSources.Compose(
-            TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer),
-            TaggerEventSources.OnWorkspaceRegistrationChanged(subjectBuffer),
-            TaggerEventSources.OnDiagnosticsChanged(subjectBuffer, diagnosticService),
-            TaggerEventSources.OnTextChanged(subjectBuffer));
-    }
-
     protected ITagSpan<TTag>? CreateTagSpan(Workspace workspace, SnapshotSpan span, DiagnosticData data)
     {
         var errorTag = CreateTag(workspace, data);
diff --git a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsTaggerProvider.cs b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsTaggerProvider.cs
index 3ad67867ea199..e44ee7473da54 100644
--- a/src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsTaggerProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineDiagnostics/InlineDiagnosticsTaggerProvider.cs
@@ -27,7 +27,6 @@ namespace Microsoft.CodeAnalysis.Editor.InlineDiagnostics;
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
 internal sealed class InlineDiagnosticsTaggerProvider(
     IThreadingContext threadingContext,
-    IDiagnosticService diagnosticService,
     IDiagnosticAnalyzerService analyzerService,
     IGlobalOptionService globalOptions,
     [Import(AllowDefault = true)] ITextBufferVisibilityTracker? visibilityTracker,
@@ -37,7 +36,6 @@ internal sealed class InlineDiagnosticsTaggerProvider(
     IClassificationTypeRegistryService classificationTypeRegistryService)
     : AbstractDiagnosticsTaggerProvider<InlineDiagnosticsTag>(
         threadingContext,
-        diagnosticService,
         analyzerService,
         globalOptions,
         visibilityTracker,
diff --git a/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.DiagnosticsChangedEventSource.cs b/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.DiagnosticsChangedEventSource.cs
deleted file mode 100644
index 56658d13a19a8..0000000000000
--- a/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.DiagnosticsChangedEventSource.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.Text;
-
-namespace Microsoft.CodeAnalysis.Editor.Shared.Tagging;
-
-internal partial class TaggerEventSources
-{
-    private class DiagnosticsChangedEventSource(ITextBuffer subjectBuffer, IDiagnosticService service) : AbstractTaggerEventSource
-    {
-        private readonly ITextBuffer _subjectBuffer = subjectBuffer;
-        private readonly IDiagnosticService _service = service;
-
-        private void OnDiagnosticsUpdated(object? sender, ImmutableArray<DiagnosticsUpdatedArgs> e)
-        {
-            var textContainer = _subjectBuffer.AsTextContainer();
-            var anyChanged = false;
-            Workspace? lastWorkspace = null;
-            DocumentId? documentId = null;
-            foreach (var args in e)
-            {
-                if (args.Workspace != lastWorkspace)
-                {
-                    lastWorkspace = args.Workspace;
-                    documentId = args.Workspace.GetDocumentIdInCurrentContext(textContainer);
-                }
-
-                if (args.DocumentId == documentId)
-                {
-                    anyChanged = true;
-                    break;
-                }
-            }
-
-            if (anyChanged)
-            {
-                this.RaiseChanged();
-            }
-        }
-
-        public override void Connect()
-            => _service.DiagnosticsUpdated += OnDiagnosticsUpdated;
-
-        public override void Disconnect()
-            => _service.DiagnosticsUpdated -= OnDiagnosticsUpdated;
-    }
-}
diff --git a/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.cs b/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.cs
index d36975a3afa9d..4c3011e0444cb 100644
--- a/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.cs
+++ b/src/EditorFeatures/Core/Shared/Tagging/EventSources/TaggerEventSources.cs
@@ -50,9 +50,6 @@ public static ITaggerEventSource OnReadOnlyRegionsChanged(ITextBuffer subjectBuf
     public static ITaggerEventSource OnGlobalOptionChanged(IGlobalOptionService globalOptions, IOption2 globalOption)
         => new GlobalOptionChangedEventSource(globalOptions, globalOption);
 
-    public static ITaggerEventSource OnDiagnosticsChanged(ITextBuffer subjectBuffer, IDiagnosticService service)
-        => new DiagnosticsChangedEventSource(subjectBuffer, service);
-
     public static ITaggerEventSource OnParseOptionChanged(ITextBuffer subjectBuffer)
         => new ParseOptionChangedEventSource(subjectBuffer);
 

From 351f72eeaee09e37ecf298da68eb77e0f6d19895 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Fri, 15 Mar 2024 10:45:14 -0700
Subject: [PATCH 087/170] Remove import

---
 .../LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs      | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs b/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs
index 912456d3fa26e..ef96a72e3debb 100644
--- a/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs
+++ b/src/VisualStudio/LiveShare/Impl/Client/RemoteLanguageServiceWorkspace.cs
@@ -80,7 +80,6 @@ public RemoteLanguageServiceWorkspace(
             OpenTextBufferProvider openTextBufferProvider,
             IVsFolderWorkspaceService vsFolderWorkspaceService,
             SVsServiceProvider serviceProvider,
-            IDiagnosticService diagnosticService,
             ITableManagerProvider tableManagerProvider,
             IThreadingContext threadingContext)
             : base(VisualStudioMefHostServices.Create(exportProvider), WorkspaceKind.CloudEnvironmentClientWorkspace)

From 93fb58100f90efe96051fe8531a008823f39c81b Mon Sep 17 00:00:00 2001
From: Charles Stoner <10732005+cston@users.noreply.github.com>
Date: Fri, 15 Mar 2024 14:24:44 -0700
Subject: [PATCH 088/170] Remove UnconvertedCollectionExpression case from
 CSharpOperationFactory (#72563)

---
 .../LocalRewriter/LocalRewriter_CollectionExpression.cs      | 5 +++++
 .../CSharp/Portable/Operations/CSharpOperationFactory.cs     | 2 --
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs
index e9036e8f11e04..ca0c4e3354ab1 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs
@@ -23,6 +23,11 @@ internal sealed partial class LocalRewriter
             throw ExceptionUtilities.Unreachable();
         }
 
+        public override BoundNode? VisitUnconvertedCollectionExpression(BoundUnconvertedCollectionExpression node)
+        {
+            throw ExceptionUtilities.Unreachable();
+        }
+
         private BoundExpression RewriteCollectionExpressionConversion(Conversion conversion, BoundCollectionExpression node)
         {
             Debug.Assert(conversion.Kind == ConversionKind.CollectionExpression);
diff --git a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
index f3a5494d78541..9a43c65d82474 100644
--- a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
+++ b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
@@ -304,8 +304,6 @@ public CSharpOperationFactory(SemanticModel semanticModel)
                 case BoundKind.StackAllocArrayCreation:
                 case BoundKind.TypeExpression:
                 case BoundKind.TypeOrValueExpression:
-                case BoundKind.UnconvertedCollectionExpression:
-
                     ConstantValue? constantValue = (boundNode as BoundExpression)?.ConstantValueOpt;
                     bool isImplicit = boundNode.WasCompilerGenerated;
 

From 19f9e658eb8bf3091875ad199fbf156e4f668762 Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Mon, 18 Mar 2024 09:14:51 -0700
Subject: [PATCH 089/170] Reduce allocations in NodeExtensions.LogTables
 (#72536)

The call to typeof(T).FullName is showing in speedometer allocation profiles as 0.8% of allocations during the session in the roslyn OOP. Although these allocations only occur when logging is on, it's still nice to get rid of them and improve our numbers and the experience of customers that have this logging on.
---
 .../Core/Portable/SourceGeneration/Nodes/BatchNode.cs     | 4 +++-
 .../Core/Portable/SourceGeneration/Nodes/CombineNode.cs   | 6 ++++--
 .../Core/Portable/SourceGeneration/Nodes/InputNode.cs     | 4 +++-
 .../Portable/SourceGeneration/Nodes/NodeExtensions.cs     | 8 ++++----
 .../Portable/SourceGeneration/Nodes/SourceOutputNode.cs   | 6 ++++--
 .../Core/Portable/SourceGeneration/Nodes/TransformNode.cs | 6 ++++--
 6 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs
index 540f8a033e804..3b803f961498b 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/BatchNode.cs
@@ -13,6 +13,8 @@ namespace Microsoft.CodeAnalysis
 {
     internal sealed class BatchNode<TInput> : IIncrementalGeneratorNode<ImmutableArray<TInput>>
     {
+        private static readonly string? s_tableType = typeof(ImmutableArray<TInput>).FullName;
+
         private readonly IIncrementalGeneratorNode<TInput> _sourceNode;
         private readonly IEqualityComparer<ImmutableArray<TInput>> _comparer;
         private readonly string? _name;
@@ -141,7 +143,7 @@ public NodeStateTable<ImmutableArray<TInput>> UpdateStateTable(DriverStateTable.
             }
 
             var newTable = tableBuilder.ToImmutableAndFree();
-            this.LogTables(_name, previousTable, newTable, sourceTable);
+            this.LogTables(_name, s_tableType, previousTable, newTable, sourceTable);
             return newTable;
         }
 
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs
index c0006fa104bc7..bd4c0d4c489c5 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/CombineNode.cs
@@ -13,6 +13,8 @@ namespace Microsoft.CodeAnalysis
 {
     internal sealed class CombineNode<TInput1, TInput2> : IIncrementalGeneratorNode<(TInput1, TInput2)>
     {
+        private static readonly string? s_tableType = typeof((TInput1, TInput2)).FullName;
+
         private readonly IIncrementalGeneratorNode<TInput1> _input1;
         private readonly IIncrementalGeneratorNode<TInput2> _input2;
         private readonly IEqualityComparer<(TInput1, TInput2)>? _comparer;
@@ -34,7 +36,7 @@ public CombineNode(IIncrementalGeneratorNode<TInput1> input1, IIncrementalGenera
 
             if (input1Table.IsCached && input2Table.IsCached && previousTable is not null)
             {
-                this.LogTables(_name, previousTable, previousTable, input1Table, input2Table);
+                this.LogTables(_name, s_tableType, previousTable, previousTable, input1Table, input2Table);
                 if (graphState.DriverState.TrackIncrementalSteps)
                 {
                     return RecordStepsForCachedTable(graphState, previousTable, input1Table, input2Table);
@@ -79,7 +81,7 @@ public CombineNode(IIncrementalGeneratorNode<TInput1> input1, IIncrementalGenera
             Debug.Assert(tableBuilder.Count == totalEntryItemCount);
 
             var newTable = tableBuilder.ToImmutableAndFree();
-            this.LogTables(_name, previousTable, newTable, input1Table, input2Table);
+            this.LogTables(_name, s_tableType, previousTable, newTable, input1Table, input2Table);
             return newTable;
         }
 
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs
index 2178a15ca5135..000c1e82c1e9b 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/InputNode.cs
@@ -19,6 +19,8 @@ namespace Microsoft.CodeAnalysis
     /// <typeparam name="T">The type of the input</typeparam>
     internal sealed class InputNode<T> : IIncrementalGeneratorNode<T>
     {
+        private static readonly string? s_tableType = typeof(T).FullName;
+
         private readonly Func<DriverStateTable.Builder, ImmutableArray<T>> _getInput;
         private readonly Action<IIncrementalGeneratorOutputNode> _registerOutput;
         private readonly IEqualityComparer<T> _inputComparer;
@@ -132,7 +134,7 @@ private void LogTables(NodeStateTable<T>? previousTable, NodeStateTable<T> newTa
             }
             var inputTable = tableBuilder.ToImmutableAndFree();
 
-            this.LogTables(_name, previousTable, newTable, inputTable);
+            this.LogTables(_name, s_tableType, previousTable, newTable, inputTable);
         }
     }
 }
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeExtensions.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeExtensions.cs
index 09addaccbbee0..5a7660401d218 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeExtensions.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/NodeExtensions.cs
@@ -6,10 +6,10 @@ namespace Microsoft.CodeAnalysis
 {
     internal static class NodeExtensions
     {
-        public static void LogTables<TSelf, TInput>(this IIncrementalGeneratorNode<TSelf> self, string? name, NodeStateTable<TSelf>? previousTable, NodeStateTable<TSelf> newTable, NodeStateTable<TInput> inputTable)
-            => LogTables<TSelf, TInput, TInput>(self, name, previousTable, newTable, inputTable, inputNode2: null);
+        public static void LogTables<TSelf, TInput>(this IIncrementalGeneratorNode<TSelf> self, string? name, string? tableType, NodeStateTable<TSelf>? previousTable, NodeStateTable<TSelf> newTable, NodeStateTable<TInput> inputTable)
+            => LogTables<TSelf, TInput, TInput>(self, name, tableType, previousTable, newTable, inputTable, inputNode2: null);
 
-        public static void LogTables<TSelf, TInput1, TInput2>(this IIncrementalGeneratorNode<TSelf> self, string? name, NodeStateTable<TSelf>? previousTable, NodeStateTable<TSelf> newTable, NodeStateTable<TInput1> inputNode1, NodeStateTable<TInput2>? inputNode2)
+        public static void LogTables<TSelf, TInput1, TInput2>(this IIncrementalGeneratorNode<TSelf> self, string? name, string? tableType, NodeStateTable<TSelf>? previousTable, NodeStateTable<TSelf> newTable, NodeStateTable<TInput1> inputNode1, NodeStateTable<TInput2>? inputNode2)
         {
             if (CodeAnalysisEventSource.Log.IsEnabled())
             {
@@ -18,7 +18,7 @@ public static void LogTables<TSelf, TInput1, TInput2>(this IIncrementalGenerator
 
                 CodeAnalysisEventSource.Log.NodeTransform(self.GetHashCode(),
                                                           name ?? "<anonymous>",
-                                                          typeof(TSelf).FullName ?? "<unknown>",
+                                                          tableType ?? "<unknown>",
                                                           previousTable?.GetHashCode() ?? -1,
                                                           previousTable?.GetPackedStates() ?? "",
                                                           newTableOpt?.GetHashCode() ?? -1,
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs
index d308188d02175..79a71f0e2e17a 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SourceOutputNode.cs
@@ -15,6 +15,8 @@ namespace Microsoft.CodeAnalysis
 {
     internal sealed class SourceOutputNode<TInput> : IIncrementalGeneratorOutputNode, IIncrementalGeneratorNode<TOutput>
     {
+        private static readonly string? s_tableType = typeof(TOutput).FullName;
+
         private readonly IIncrementalGeneratorNode<TInput> _source;
 
         private readonly Action<SourceProductionContext, TInput, CancellationToken> _action;
@@ -41,7 +43,7 @@ public NodeStateTable<TOutput> UpdateStateTable(DriverStateTable.Builder graphSt
             var sourceTable = graphState.GetLatestStateTableForNode(_source);
             if (sourceTable.IsCached && previousTable is not null)
             {
-                this.LogTables(stepName, previousTable, previousTable, sourceTable);
+                this.LogTables(stepName, s_tableType, previousTable, previousTable, sourceTable);
                 if (graphState.DriverState.TrackIncrementalSteps)
                 {
                     return previousTable.CreateCachedTableWithUpdatedSteps(sourceTable, stepName, EqualityComparer<TOutput>.Default);
@@ -83,7 +85,7 @@ public NodeStateTable<TOutput> UpdateStateTable(DriverStateTable.Builder graphSt
             }
 
             var newTable = tableBuilder.ToImmutableAndFree();
-            this.LogTables(stepName, previousTable, newTable, sourceTable);
+            this.LogTables(stepName, s_tableType, previousTable, newTable, sourceTable);
             return newTable;
         }
 
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs
index 77b298343331f..d63edba0ce260 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/TransformNode.cs
@@ -15,6 +15,8 @@ namespace Microsoft.CodeAnalysis
 {
     internal sealed class TransformNode<TInput, TOutput> : IIncrementalGeneratorNode<TOutput>
     {
+        private static readonly string? s_tableType = typeof(TOutput).FullName;
+
         private readonly Func<TInput, CancellationToken, ImmutableArray<TOutput>> _func;
         private readonly IEqualityComparer<TOutput> _comparer;
         private readonly IIncrementalGeneratorNode<TInput> _sourceNode;
@@ -47,7 +49,7 @@ public NodeStateTable<TOutput> UpdateStateTable(DriverStateTable.Builder builder
             var sourceTable = builder.GetLatestStateTableForNode(_sourceNode);
             if (sourceTable.IsCached && previousTable is not null)
             {
-                this.LogTables(_name, previousTable, previousTable, sourceTable);
+                this.LogTables(_name, s_tableType, previousTable, previousTable, sourceTable);
                 if (builder.DriverState.TrackIncrementalSteps)
                 {
                     return previousTable.CreateCachedTableWithUpdatedSteps(sourceTable, _name, _comparer);
@@ -95,7 +97,7 @@ public NodeStateTable<TOutput> UpdateStateTable(DriverStateTable.Builder builder
             // Can't assert anything about the count of items.  _func may have produced a different amount of items if
             // it's not a 1:1 function.
             var newTable = tableBuilder.ToImmutableAndFree();
-            this.LogTables(_name, previousTable, newTable, sourceTable);
+            this.LogTables(_name, s_tableType, previousTable, newTable, sourceTable);
             return newTable;
         }
 

From 9e216ac9cf49c3e67229754d75c4927d8009ea27 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 10:38:22 -0700
Subject: [PATCH 090/170] In progress

---
 .../CSharp/CSharpEditorResources.resx         |  3 +
 ...EventHookupCommandHandler_TabKeyCommand.cs | 62 ++++++++++++++-----
 ...entHookupCommandHandler_TypeCharCommand.cs |  4 +-
 .../EventHookup/EventHookupSessionManager.cs  | 19 +++---
 ...HookupSessionManager_EventHookupSession.cs |  2 +-
 5 files changed, 64 insertions(+), 26 deletions(-)

diff --git a/src/EditorFeatures/CSharp/CSharpEditorResources.resx b/src/EditorFeatures/CSharp/CSharpEditorResources.resx
index 8c8b76fd5f9a9..84d8a5338b597 100644
--- a/src/EditorFeatures/CSharp/CSharpEditorResources.resx
+++ b/src/EditorFeatures/CSharp/CSharpEditorResources.resx
@@ -155,4 +155,7 @@
   <data name="Fixing_string_literal_after_paste" xml:space="preserve">
     <value>Fixing string literal after paste</value>
   </data>
+  <data name="Generating_event" xml:space="preserve">
+    <value>Generating event ...</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index c4c3702a81936..c53085d63098e 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -15,6 +15,7 @@
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Editor.BackgroundWorkIndicator;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.EventHookup;
@@ -37,41 +38,44 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.EventHookup;
 
 internal partial class EventHookupCommandHandler : IChainedCommandHandler<TabKeyCommandArgs>
 {
-    public void ExecuteCommand(TabKeyCommandArgs args, Action nextHandler, CommandExecutionContext context)
+    public CommandState GetCommandState(TabKeyCommandArgs args, Func<CommandState> nextHandler)
     {
         _threadingContext.ThrowIfNotOnUIThread();
-        if (!_globalOptions.GetOption(EventHookupOptionsStorage.EventHookup))
+        if (EventHookupSessionManager.CurrentSession != null)
         {
-            nextHandler();
-            return;
+            return CommandState.Available;
         }
-
-        if (EventHookupSessionManager.CurrentSession == null)
+        else
         {
-            nextHandler();
-            return;
+            return nextHandler();
         }
-
-        // Handling tab is currently uncancellable.
-        HandleTabWorker(args.TextView, args.SubjectBuffer, nextHandler, CancellationToken.None);
     }
 
-    public CommandState GetCommandState(TabKeyCommandArgs args, Func<CommandState> nextHandler)
+    public void ExecuteCommand(TabKeyCommandArgs args, Action nextHandler, CommandExecutionContext context)
     {
         _threadingContext.ThrowIfNotOnUIThread();
-        if (EventHookupSessionManager.CurrentSession != null)
+        if (!TryExecuteCommand(args, context))
         {
-            return CommandState.Available;
+            // If we didn't process this tag to emit an event handler, just pass the tab through to the buffer normally.
+            EventHookupSessionManager.DismissExistingSessions(cancelBackgroundTasks: true);
+            nextHandler();
         }
         else
         {
-            return nextHandler();
+            // Ensure no matter what that once tab is hit that we're back to the initial no-session state. We do not
+            // want to cancel the bg tasks kicked off as we need their values to actually emit the event.
+            EventHookupSessionManager.DismissExistingSessions(cancelBackgroundTasks: false);
         }
     }
 
-    private void HandleTabWorker(ITextView textView, ITextBuffer subjectBuffer, Action nextHandler, CancellationToken cancellationToken)
-    {
+    private bool TryExecuteCommand(TabKeyCommandArgs args, CommandExecutionContext context)
+    { 
         _threadingContext.ThrowIfNotOnUIThread();
+        if (!_globalOptions.GetOption(EventHookupOptionsStorage.EventHookup))
+            return false;
+
+        if (EventHookupSessionManager.CurrentSession == null)
+            return false;
 
         // For test purposes only!
         if (EventHookupSessionManager.CurrentSession.TESTSessionHookupMutex != null)
@@ -85,6 +89,30 @@ private void HandleTabWorker(ITextView textView, ITextBuffer subjectBuffer, Acti
             }
         }
 
+        var currentSnapshot = args.SubjectBuffer.CurrentSnapshot;
+        var document = currentSnapshot.GetOpenDocumentInCurrentContextWithChanges();
+        if (document is null)
+            return false;
+
+        // First, dismiss the existing tooltip.  We'll be replacing it with the lightweight background wait indicator.
+        EventHookupSessionManager.DismissTooltip();
+
+        // Now emit the event asynchronously.
+        var token = _asyncListener.BeginAsyncOperation(nameof(ExecuteCommand));
+
+        // Capture everything we'll need as we'll be dismissing the core session immediately after we kick off this work.
+        var task = ExecuteCommandAsync();
+        task.Completes(token)
+
+        // At this point, we've taken control, so don't send the tab into the buffer.  But do dismiss the overall
+        // session.  We no longer need it.
+        return true;
+        var factory = document.Project.Solution.Workspace.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>();
+        factory.Create(
+            args.TextView,
+            EventHookupSessionManager.CurrentSession.TrackingSpan.GetSpan(currentSnapshot),
+            CSharpEditorResources.Generating_event);
+ 
         // Blocking wait (if necessary) to determine whether to consume the tab and
         // generate the event handler.
         EventHookupSessionManager.CurrentSession.GetEventNameTask.Wait(cancellationToken);
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
index a906b99debfba..659d21c00a87f 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
@@ -67,7 +67,9 @@ private bool IsTextualPlusEquals(ITextView textView, ITextBuffer subjectBuffer)
         }
 
         var position = caretPoint.Value.Position;
-        return position - 2 >= 0 && subjectBuffer.CurrentSnapshot.GetText(position - 2, 2) == "+=";
+        return position - 2 >= 0 &&
+            subjectBuffer.CurrentSnapshot[position - 1] == '=' &&
+            subjectBuffer.CurrentSnapshot[position - 2] == '+';
     }
 
     public CommandState GetCommandState(TypeCharCommandArgs args, Func<CommandState> nextHandler)
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
index 9b9c8baad59f2..281c4018bac41 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
@@ -114,22 +114,27 @@ internal void BeginSession(
         CurrentSession = new EventHookupSession(this, eventHookupCommandHandler, textView, subjectBuffer, asyncListener, _globalOptions, testSessionHookupMutex);
     }
 
-    internal void CancelAndDismissExistingSessions()
+    public void CancelAndDismissExistingSessions()
+        => DismissExistingSessions(cancelBackgroundTasks: true);
+
+    public void DismissExistingSessions(bool cancelBackgroundTasks)
     {
         ThreadingContext.ThrowIfNotOnUIThread();
 
-        if (CurrentSession != null)
-        {
-            CurrentSession.Cancel();
-            CurrentSession = null;
-        }
-
         if (_toolTipPresenter != null)
         {
             _toolTipPresenter.Dismiss();
             _toolTipPresenter = null;
         }
 
+        if (CurrentSession != null)
+        {
+            if (cancelBackgroundTasks)
+                CurrentSession.CancelBackgroundTasks();
+
+            CurrentSession = null;
+        }
+
         // For test purposes only!
         TEST_MostRecentToolTipContent = null;
     }
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
index f5d25b51cccac..c6bdecf6f766b 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
@@ -90,7 +90,7 @@ public ITextBuffer SubjectBuffer
             }
         }
 
-        public void Cancel()
+        public void CancelBackgroundTasks()
         {
             _threadingContext.ThrowIfNotOnUIThread();
             _cancellationTokenSource.Cancel();

From a9e7443d2fcff9e089656bdb31c3ffd95d18beac Mon Sep 17 00:00:00 2001
From: Shen Chen <Cosifne@users.noreply.github.com>
Date: Mon, 18 Mar 2024 10:43:46 -0700
Subject: [PATCH 091/170] Localize 17.10 (#72570)

---
 azure-pipelines-official.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index 13185deb277d8..2ade37f0b2509 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -81,11 +81,11 @@ stages:
     demands: ImageOverride -equals windows.vs2022preview.amd64
 
   jobs:
-  - ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/release/dev17.9') }}:
+  - ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/release/dev17.10') }}:
     - template: /eng/common/templates/job/onelocbuild.yml
       parameters:
         MirrorRepo: roslyn
-        MirrorBranch: release/dev17.9
+        MirrorBranch: release/dev17.10
         LclSource: lclFilesfromPackage
         LclPackageId: 'LCL-JUNO-PROD-ROSLYN'
 

From bc438076c8a63334d273eff155c769171aec073a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 11:08:31 -0700
Subject: [PATCH 092/170] In progress

---
 ...EventHookupCommandHandler_TabKeyCommand.cs | 191 +++++++++---------
 .../EventHookup/EventHookupSessionManager.cs  |   3 +-
 .../CSharp/xlf/CSharpEditorResources.cs.xlf   |   5 +
 .../CSharp/xlf/CSharpEditorResources.de.xlf   |   5 +
 .../CSharp/xlf/CSharpEditorResources.es.xlf   |   5 +
 .../CSharp/xlf/CSharpEditorResources.fr.xlf   |   5 +
 .../CSharp/xlf/CSharpEditorResources.it.xlf   |   5 +
 .../CSharp/xlf/CSharpEditorResources.ja.xlf   |   5 +
 .../CSharp/xlf/CSharpEditorResources.ko.xlf   |   5 +
 .../CSharp/xlf/CSharpEditorResources.pl.xlf   |   5 +
 .../xlf/CSharpEditorResources.pt-BR.xlf       |   5 +
 .../CSharp/xlf/CSharpEditorResources.ru.xlf   |   5 +
 .../CSharp/xlf/CSharpEditorResources.tr.xlf   |   5 +
 .../xlf/CSharpEditorResources.zh-Hans.xlf     |   5 +
 .../xlf/CSharpEditorResources.zh-Hant.xlf     |   5 +
 15 files changed, 168 insertions(+), 91 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index c53085d63098e..c6c6feeb10a98 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Editor.BackgroundWorkIndicator;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.EventHookup;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Internal.Log;
@@ -25,6 +26,7 @@
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Rename;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
@@ -32,6 +34,7 @@
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
+using Microsoft.VisualStudio.Threading;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.EventHookup;
@@ -54,22 +57,16 @@ public CommandState GetCommandState(TabKeyCommandArgs args, Func<CommandState> n
     public void ExecuteCommand(TabKeyCommandArgs args, Action nextHandler, CommandExecutionContext context)
     {
         _threadingContext.ThrowIfNotOnUIThread();
-        if (!TryExecuteCommand(args, context))
+        if (!TryExecuteCommand(args, nextHandler))
         {
             // If we didn't process this tag to emit an event handler, just pass the tab through to the buffer normally.
             EventHookupSessionManager.DismissExistingSessions(cancelBackgroundTasks: true);
             nextHandler();
         }
-        else
-        {
-            // Ensure no matter what that once tab is hit that we're back to the initial no-session state. We do not
-            // want to cancel the bg tasks kicked off as we need their values to actually emit the event.
-            EventHookupSessionManager.DismissExistingSessions(cancelBackgroundTasks: false);
-        }
     }
 
-    private bool TryExecuteCommand(TabKeyCommandArgs args, CommandExecutionContext context)
-    { 
+    private bool TryExecuteCommand(TabKeyCommandArgs args, Action nextHandler)
+    {
         _threadingContext.ThrowIfNotOnUIThread();
         if (!_globalOptions.GetOption(EventHookupOptionsStorage.EventHookup))
             return false;
@@ -89,86 +86,99 @@ private bool TryExecuteCommand(TabKeyCommandArgs args, CommandExecutionContext c
             }
         }
 
-        var currentSnapshot = args.SubjectBuffer.CurrentSnapshot;
+        var subjectBuffer = args.SubjectBuffer;
+        var caretPoint = args.TextView.GetCaretPoint(subjectBuffer);
+        if (caretPoint is null)
+            return false;
+
+        var currentSnapshot = subjectBuffer.CurrentSnapshot;
         var document = currentSnapshot.GetOpenDocumentInCurrentContextWithChanges();
         if (document is null)
             return false;
 
-        // First, dismiss the existing tooltip.  We'll be replacing it with the lightweight background wait indicator.
-        EventHookupSessionManager.DismissTooltip();
-
         // Now emit the event asynchronously.
         var token = _asyncListener.BeginAsyncOperation(nameof(ExecuteCommand));
 
-        // Capture everything we'll need as we'll be dismissing the core session immediately after we kick off this work.
-        var task = ExecuteCommandAsync();
-        task.Completes(token)
+        // Capture everything we need off of the session manager as we'll be dismissing the core session immediately
+        // before we kick off the work to emit hte event.
+        var eventNameTask = EventHookupSessionManager.CurrentSession.GetEventNameTask;
+        var applicableToSpan = EventHookupSessionManager.CurrentSession.TrackingSpan.GetSpan(currentSnapshot);
+
+        // Ensure no matter what that once tab is hit that we're back to the initial no-session state. We do not
+        // want to cancel the bg tasks kicked off as we need their values to actually emit the event.
+        EventHookupSessionManager.DismissExistingSessions(cancelBackgroundTasks: false);
+
+        var task = ExecuteCommandAsync(
+            args,
+            nextHandler,
+            applicableToSpan,
+            document,
+            eventNameTask,
+            caretPoint.Value);
+        task.CompletesAsyncOperation(token);
 
         // At this point, we've taken control, so don't send the tab into the buffer.  But do dismiss the overall
         // session.  We no longer need it.
         return true;
-        var factory = document.Project.Solution.Workspace.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>();
-        factory.Create(
-            args.TextView,
-            EventHookupSessionManager.CurrentSession.TrackingSpan.GetSpan(currentSnapshot),
-            CSharpEditorResources.Generating_event);
- 
-        // Blocking wait (if necessary) to determine whether to consume the tab and
-        // generate the event handler.
-        EventHookupSessionManager.CurrentSession.GetEventNameTask.Wait(cancellationToken);
-
-        string eventHandlerMethodName = null;
-        if (EventHookupSessionManager.CurrentSession.GetEventNameTask.Status == TaskStatus.RanToCompletion)
+    }
+
+    private async Task ExecuteCommandAsync(
+        TabKeyCommandArgs args,
+        Action nextHandler,
+        SnapshotSpan applicableToSpan,
+        Document document,
+        Task<string> getEventNameTask,
+        SnapshotPoint initialCaretPoint)
+    {
+        try
         {
-            eventHandlerMethodName = EventHookupSessionManager.CurrentSession.GetEventNameTask.WaitAndGetResult(cancellationToken);
+            _threadingContext.ThrowIfNotOnUIThread();
+            await ExecuteCommandWorkerAsync().ConfigureAwait(false);
         }
-
-        if (eventHandlerMethodName == null ||
-            EventHookupSessionManager.CurrentSession.TextView != textView)
+        catch (OperationCanceledException)
+        {
+        }
+        catch (Exception ex) when (FatalError.ReportAndCatch(ex))
         {
-            nextHandler();
-            EventHookupSessionManager.CancelAndDismissExistingSessions();
-            return;
         }
 
-        // This tab means we should generate the event handler method. Begin the code
-        // generation process.
-        GenerateAndAddEventHandler(textView, subjectBuffer, eventHandlerMethodName, nextHandler, cancellationToken);
-    }
+        return;
 
-    private void GenerateAndAddEventHandler(ITextView textView, ITextBuffer subjectBuffer, string eventHandlerMethodName, Action nextHandler, CancellationToken cancellationToken)
-    {
-        _threadingContext.ThrowIfNotOnUIThread();
-
-        using (Logger.LogBlock(FunctionId.EventHookup_Generate_Handler, cancellationToken))
+        async Task ExecuteCommandWorkerAsync()
         {
-            EventHookupSessionManager.CancelAndDismissExistingSessions();
+            var textView = args.TextView;
+            var subjectBuffer = args.SubjectBuffer;
 
-            var workspace = textView.TextSnapshot.TextBuffer.GetWorkspace();
-            if (workspace == null)
-            {
-                nextHandler();
-                EventHookupSessionManager.CancelAndDismissExistingSessions();
-                return;
-            }
+            var factory = document.Project.Solution.Workspace.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>();
+            using var waitContext = factory.Create(
+                textView,
+                applicableToSpan,
+                CSharpEditorResources.Generating_event);
 
-            var document = textView.TextSnapshot.GetOpenDocumentInCurrentContextWithChanges();
-            Contract.ThrowIfNull(document, "Event Hookup could not find the document for the IBufferView.");
+            var cancellationToken = waitContext.UserCancellationToken;
 
-            var position = textView.GetCaretPoint(subjectBuffer).Value.Position;
-            var solutionWithEventHandler = CreateSolutionWithEventHandler(
-                document,
-                eventHandlerMethodName,
-                position,
-                out var plusEqualTokenEndPosition,
-                _globalOptions,
-                cancellationToken);
+            var eventHandlerMethodName = await getEventNameTask.WithCancellation(cancellationToken).ConfigureAwait(false);
 
-            Contract.ThrowIfNull(solutionWithEventHandler, "Event Hookup could not create solution with event handler.");
+            var solutionAndPosition = await TryGetNewSolutionWithAddedMethodAsync(
+                document, eventHandlerMethodName, initialCaretPoint.Position, cancellationToken).ConfigureAwait(false);
 
-            // The new solution is created, so start user observable changes
+            // We're about to make an edit ourselves.  so disable the cancellation that happens on editing.
+            waitContext.CancelOnEdit = false;
 
-            Contract.ThrowIfFalse(workspace.TryApplyChanges(solutionWithEventHandler), "Event Hookup could not update the solution.");
+            // switch back to the UI thread.
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            // If anything changed in the view between computation and application, bail out.
+            if (solutionAndPosition is null ||
+                applicableToSpan.Snapshot.Version != subjectBuffer.CurrentSnapshot.Version ||
+                textView.GetCaretPoint(subjectBuffer) != initialCaretPoint)
+            {
+                nextHandler();
+                return;
+            }
+
+            var (solutionWithEventHandler, plusEqualTokenEndPosition) = solutionAndPosition.Value;
+            document.Project.Solution.Workspace.TryApplyChanges(solutionWithEventHandler);
 
             // The += token will not move during this process, so it is safe to use that
             // position as a location from which to find the identifier we're renaming.
@@ -176,43 +186,44 @@ private void GenerateAndAddEventHandler(ITextView textView, ITextBuffer subjectB
         }
     }
 
-    private Solution CreateSolutionWithEventHandler(
-        Document document,
-        string eventHandlerMethodName,
-        int position,
-        out int plusEqualTokenEndPosition,
-        IGlobalOptionService globalOptions,
-        CancellationToken cancellationToken)
+    private async Task<(Solution solution, int plusEqualTokenEndPosition)?> TryGetNewSolutionWithAddedMethodAsync(
+        Document document, string eventHandlerMethodName, int position, CancellationToken cancellationToken)
     {
         _threadingContext.ThrowIfNotOnUIThread();
 
         // Mark the += token with an annotation so we can find it after formatting
         var plusEqualsTokenAnnotation = new SyntaxAnnotation();
 
-        var documentWithNameAndAnnotationsAdded = AddMethodNameAndAnnotationsToSolution(document, eventHandlerMethodName, position, plusEqualsTokenAnnotation, cancellationToken);
-        var semanticDocument = SemanticDocument.CreateAsync(documentWithNameAndAnnotationsAdded, cancellationToken).WaitAndGetResult(cancellationToken);
-        var options = (CSharpCodeGenerationOptions)document.GetCodeGenerationOptionsAsync(globalOptions, cancellationToken).AsTask().WaitAndGetResult(cancellationToken);
-        var updatedRoot = AddGeneratedHandlerMethodToSolution(semanticDocument, options, eventHandlerMethodName, plusEqualsTokenAnnotation, cancellationToken);
+        var documentWithNameAndAnnotationsAdded = await AddMethodNameAndAnnotationsToSolutionAsync(
+            document, eventHandlerMethodName, position, plusEqualsTokenAnnotation, cancellationToken).ConfigureAwait(false);
+        var semanticDocument = await SemanticDocument.CreateAsync(
+            documentWithNameAndAnnotationsAdded, cancellationToken).ConfigureAwait(false);
+        var options = (CSharpCodeGenerationOptions)await document.GetCodeGenerationOptionsAsync(
+            globalOptions, cancellationToken).ConfigureAwait(false);
+        var updatedRoot = AddGeneratedHandlerMethodToSolution(
+            semanticDocument, options, eventHandlerMethodName, plusEqualsTokenAnnotation, cancellationToken);
 
         if (updatedRoot == null)
-        {
-            plusEqualTokenEndPosition = 0;
             return null;
-        }
 
-        var cleanupOptions = documentWithNameAndAnnotationsAdded.GetCodeCleanupOptionsAsync(globalOptions, cancellationToken).AsTask().WaitAndGetResult(cancellationToken);
-        var simplifiedDocument = Simplifier.ReduceAsync(documentWithNameAndAnnotationsAdded.WithSyntaxRoot(updatedRoot), Simplifier.Annotation, cleanupOptions.SimplifierOptions, cancellationToken).WaitAndGetResult(cancellationToken);
-        var formattedDocument = Formatter.FormatAsync(simplifiedDocument, Formatter.Annotation, cleanupOptions.FormattingOptions, cancellationToken).WaitAndGetResult(cancellationToken);
+        var cleanupOptions = await documentWithNameAndAnnotationsAdded.GetCodeCleanupOptionsAsync(
+            globalOptions, cancellationToken).ConfigureAwait(false);
+        var simplifiedDocument = await Simplifier.ReduceAsync(
+            documentWithNameAndAnnotationsAdded.WithSyntaxRoot(updatedRoot), Simplifier.Annotation, cleanupOptions.SimplifierOptions, cancellationToken).ConfigureAwait(false);
+        var formattedDocument = await Formatter.FormatAsync(
+            simplifiedDocument, Formatter.Annotation, cleanupOptions.FormattingOptions, cancellationToken).ConfigureAwait(false);
 
-        var newRoot = formattedDocument.GetSyntaxRootSynchronously(cancellationToken);
-        plusEqualTokenEndPosition = newRoot.GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation)
+        var newRoot = await formattedDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        var plusEqualTokenEndPosition = newRoot.GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation)
                                            .Single().Span.End;
 
-        return document.Project.Solution.WithDocumentText(
-            formattedDocument.Id, formattedDocument.GetTextSynchronously(cancellationToken));
+        var newText = await formattedDocument.GetTextAsync(cancellationToken).ConfigureAwait(false);
+        var newSolution = document.Project.Solution.WithDocumentText(formattedDocument.Id, newText);
+
+        return (newSolution, plusEqualTokenEndPosition);
     }
 
-    private static Document AddMethodNameAndAnnotationsToSolution(
+    private static async Task<Document> AddMethodNameAndAnnotationsToSolutionAsync(
         Document document,
         string eventHandlerMethodName,
         int position,
@@ -220,7 +231,7 @@ private static Document AddMethodNameAndAnnotationsToSolution(
         CancellationToken cancellationToken)
     {
         // First find the event hookup to determine if we are in a static context.
-        var root = document.GetSyntaxRootSynchronously(cancellationToken);
+        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
         var plusEqualsToken = root.FindTokenOnLeftOfPosition(position);
         var eventHookupExpression = plusEqualsToken.GetAncestor<AssignmentExpressionSyntax>();
         var typeDecl = eventHookupExpression.GetAncestor<TypeDeclarationSyntax>();
@@ -234,11 +245,11 @@ private static Document AddMethodNameAndAnnotationsToSolution(
 
         // Next, perform a textual insertion of the event handler method name.
         var textChange = new TextChange(new TextSpan(position, 0), textToInsert);
-        var newText = document.GetTextSynchronously(cancellationToken).WithChanges(textChange);
+        var newText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
         var documentWithNameAdded = document.WithText(newText);
 
         // Now find the event hookup again to add the appropriate annotations.
-        root = documentWithNameAdded.GetSyntaxRootSynchronously(cancellationToken);
+        root = await documentWithNameAdded.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
         plusEqualsToken = root.FindTokenOnLeftOfPosition(position);
         eventHookupExpression = plusEqualsToken.GetAncestor<AssignmentExpressionSyntax>();
 
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
index 281c4018bac41..24b98f380f813 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
@@ -6,6 +6,7 @@
 
 using System;
 using System.ComponentModel.Composition;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.Classification;
@@ -17,7 +18,6 @@
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Adornments;
 using Microsoft.VisualStudio.Text.Editor;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.EventHookup;
 
@@ -183,6 +183,7 @@ private void Caret_PositionChanged(object sender, EventArgs e)
         }
     }
 
+    [MemberNotNullWhen(true, nameof(CurrentSession))]
     internal bool IsTrackingSession()
         => CurrentSession != null;
 }
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
index 50ab629051ed8..0ae38e09543e1 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Generovat odběr událostí</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Zvětšit nezpracovaný řetězec</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
index 91162572a6c3b..cde5e6b51ccf2 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Ereignisabonnement generieren</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Rohzeichenfolge vergrößern</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
index f65e7f35876f8..7e4c5a21b43e9 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Generar suscripción de eventos</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Aumentar cadena sin formato</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
index 1f17b43a90155..0b48846e062d3 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Générer un abonnement à des événements</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Agrandir la chaîne brute</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
index 1b1805a6fe538..03b937def948b 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Genera sottoscrizione di eventi</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Aumenta stringa non elaborata</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
index d4ef4611cdc89..cf524c4dc2991 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
@@ -32,6 +32,11 @@
         <target state="translated">イベント サブスクリプションの生成</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">生文字列の拡張</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
index ff6a5f4827cf9..17bc834eae64c 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
@@ -32,6 +32,11 @@
         <target state="translated">이벤트 구독 생성</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">원시 문자열 증가</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
index bbe7e76ea6dee..8f8ba8a4936ed 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Generuj subskrypcję zdarzenia</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Zwiększ nieprzetworzony ciąg</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
index 2851fad55fecd..c63add72bb5e3 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Gerar Assinatura de Evento</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Aumentar cadeia de caracteres bruta</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
index 0293b9f5a7c3c..803a218f49b90 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Создать подписку на события</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Увеличить необработанную строку</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
index 5b0129b05b0c8..775295e1e3363 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
@@ -32,6 +32,11 @@
         <target state="translated">Olay Aboneliği Oluştur</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">Ham dizeyi büyüt</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
index c0b099debc1f3..0f69a0731b175 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
@@ -32,6 +32,11 @@
         <target state="translated">生成事件订阅</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">增长原始字符串</target>
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
index 90b7f83d512dd..13c0bfbb305d6 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
@@ -32,6 +32,11 @@
         <target state="translated">產生事件訂閱</target>
         <note />
       </trans-unit>
+      <trans-unit id="Generating_event">
+        <source>Generating event ...</source>
+        <target state="new">Generating event ...</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Grow_raw_string">
         <source>Grow raw string</source>
         <target state="translated">放大原始字串</target>

From 7f5176047dd4d4a2679f753349fcb2c10eaf13cf Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 11:13:11 -0700
Subject: [PATCH 093/170] Almost done

---
 ...EventHookupCommandHandler_TabKeyCommand.cs | 62 ++++++-------------
 1 file changed, 20 insertions(+), 42 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index c6c6feeb10a98..4f79e0e09d8aa 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -2,10 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,14 +14,10 @@
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Editor.BackgroundWorkIndicator;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
-using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.EventHookup;
 using Microsoft.CodeAnalysis.Formatting;
-using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.LanguageService;
-using Microsoft.CodeAnalysis.Options;
-using Microsoft.CodeAnalysis.Rename;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Simplification;
@@ -35,7 +28,6 @@
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
 using Microsoft.VisualStudio.Threading;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.EventHookup;
 
@@ -159,7 +151,7 @@ async Task ExecuteCommandWorkerAsync()
 
             var eventHandlerMethodName = await getEventNameTask.WithCancellation(cancellationToken).ConfigureAwait(false);
 
-            var solutionAndPosition = await TryGetNewSolutionWithAddedMethodAsync(
+            var solutionAndRenameSpan = await TryGetNewSolutionWithAddedMethodAsync(
                 document, eventHandlerMethodName, initialCaretPoint.Position, cancellationToken).ConfigureAwait(false);
 
             // We're about to make an edit ourselves.  so disable the cancellation that happens on editing.
@@ -167,9 +159,10 @@ async Task ExecuteCommandWorkerAsync()
 
             // switch back to the UI thread.
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+            _threadingContext.ThrowIfNotOnUIThread();
 
             // If anything changed in the view between computation and application, bail out.
-            if (solutionAndPosition is null ||
+            if (solutionAndRenameSpan is null ||
                 applicableToSpan.Snapshot.Version != subjectBuffer.CurrentSnapshot.Version ||
                 textView.GetCaretPoint(subjectBuffer) != initialCaretPoint)
             {
@@ -177,16 +170,16 @@ async Task ExecuteCommandWorkerAsync()
                 return;
             }
 
-            var (solutionWithEventHandler, plusEqualTokenEndPosition) = solutionAndPosition.Value;
+            var (solutionWithEventHandler, renameSpan) = solutionAndRenameSpan.Value;
             document.Project.Solution.Workspace.TryApplyChanges(solutionWithEventHandler);
+            _threadingContext.ThrowIfNotOnUIThread();
 
-            // The += token will not move during this process, so it is safe to use that
-            // position as a location from which to find the identifier we're renaming.
-            BeginInlineRename(textView, plusEqualTokenEndPosition, cancellationToken);
+            _inlineRenameService.StartInlineSession(document, renameSpan, cancellationToken);
+            textView.SetSelection(renameSpan.ToSnapshotSpan(subjectBuffer.CurrentSnapshot));
         }
     }
 
-    private async Task<(Solution solution, int plusEqualTokenEndPosition)?> TryGetNewSolutionWithAddedMethodAsync(
+    private async Task<(Solution solution, TextSpan renameSpan)?> TryGetNewSolutionWithAddedMethodAsync(
         Document document, string eventHandlerMethodName, int position, CancellationToken cancellationToken)
     {
         _threadingContext.ThrowIfNotOnUIThread();
@@ -220,7 +213,18 @@ async Task ExecuteCommandWorkerAsync()
         var newText = await formattedDocument.GetTextAsync(cancellationToken).ConfigureAwait(false);
         var newSolution = document.Project.Solution.WithDocumentText(formattedDocument.Id, newText);
 
-        return (newSolution, plusEqualTokenEndPosition);
+        var finalDocument = newSolution.GetRequiredDocument(formattedDocument.Id);
+        var finalRoot = await finalDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        var token = finalRoot.FindTokenOnRightOfPosition(plusEqualTokenEndPosition);
+        var renameSpan = token.Span;
+        var memberAccessExpression = token.GetAncestor<MemberAccessExpressionSyntax>();
+        if (memberAccessExpression != null)
+        {
+            // the event hookup might look like `MyEvent += this.GeneratedHandlerName;`
+            renameSpan = memberAccessExpression.Name.Span;
+        }
+
+        return (newSolution, renameSpan);
     }
 
     private static async Task<Document> AddMethodNameAndAnnotationsToSolutionAsync(
@@ -327,30 +331,4 @@ private static IMethodSymbol GetMethodSymbol(
             parameters: delegateInvokeMethod.Parameters,
             statements: [CodeGenerationHelpers.GenerateThrowStatement(syntaxFactory, semanticDocument, "System.NotImplementedException")]);
     }
-
-    private void BeginInlineRename(ITextView textView, int plusEqualTokenEndPosition, CancellationToken cancellationToken)
-    {
-        _threadingContext.ThrowIfNotOnUIThread();
-
-        if (_inlineRenameService.ActiveSession == null)
-        {
-            var document = textView.TextSnapshot.GetOpenDocumentInCurrentContextWithChanges();
-            if (document != null)
-            {
-                // In the middle of a user action, cannot cancel.
-                var root = document.GetSyntaxRootSynchronously(cancellationToken);
-                var token = root.FindTokenOnRightOfPosition(plusEqualTokenEndPosition);
-                var editSpan = token.Span;
-                var memberAccessExpression = token.GetAncestor<MemberAccessExpressionSyntax>();
-                if (memberAccessExpression != null)
-                {
-                    // the event hookup might look like `MyEvent += this.GeneratedHandlerName;`
-                    editSpan = memberAccessExpression.Name.Span;
-                }
-
-                _inlineRenameService.StartInlineSession(document, editSpan, cancellationToken);
-                textView.SetSelection(editSpan.ToSnapshotSpan(textView.TextSnapshot));
-            }
-        }
-    }
 }

From 21a9d0ee141ad6ebe79c77052ebd112aee3fe810 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 11:42:30 -0700
Subject: [PATCH 094/170] Fixes

---
 ...EventHookupCommandHandler_TabKeyCommand.cs | 80 ++++++++++++-------
 1 file changed, 49 insertions(+), 31 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index 4f79e0e09d8aa..072413d23ef33 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using ICSharpCode.Decompiler.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CodeCleanup;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
@@ -25,9 +26,9 @@
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
 using Microsoft.VisualStudio.Threading;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.EventHookup;
 
@@ -171,11 +172,19 @@ async Task ExecuteCommandWorkerAsync()
             }
 
             var (solutionWithEventHandler, renameSpan) = solutionAndRenameSpan.Value;
-            document.Project.Solution.Workspace.TryApplyChanges(solutionWithEventHandler);
-            _threadingContext.ThrowIfNotOnUIThread();
+            var workspace = document.Project.Solution.Workspace;
+            if (workspace.TryApplyChanges(solutionWithEventHandler))
+            {
+                _threadingContext.ThrowIfNotOnUIThread();
+
+                if (_inlineRenameService.ActiveSession is null)
+                {
+                    var updatedDocument = workspace.CurrentSolution.GetRequiredDocument(document.Id);
+                    _inlineRenameService.StartInlineSession(updatedDocument, renameSpan, cancellationToken);
+                }
 
-            _inlineRenameService.StartInlineSession(document, renameSpan, cancellationToken);
-            textView.SetSelection(renameSpan.ToSnapshotSpan(subjectBuffer.CurrentSnapshot));
+                textView.SetSelection(renameSpan.ToSnapshotSpan(subjectBuffer.CurrentSnapshot));
+            }
         }
     }
 
@@ -189,6 +198,9 @@ async Task ExecuteCommandWorkerAsync()
 
         var documentWithNameAndAnnotationsAdded = await AddMethodNameAndAnnotationsToSolutionAsync(
             document, eventHandlerMethodName, position, plusEqualsTokenAnnotation, cancellationToken).ConfigureAwait(false);
+        if (documentWithNameAndAnnotationsAdded is null)
+            return null;
+
         var semanticDocument = await SemanticDocument.CreateAsync(
             documentWithNameAndAnnotationsAdded, cancellationToken).ConfigureAwait(false);
         var options = (CSharpCodeGenerationOptions)await document.GetCodeGenerationOptionsAsync(
@@ -206,15 +218,16 @@ async Task ExecuteCommandWorkerAsync()
         var formattedDocument = await Formatter.FormatAsync(
             simplifiedDocument, Formatter.Annotation, cleanupOptions.FormattingOptions, cancellationToken).ConfigureAwait(false);
 
-        var newRoot = await formattedDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-        var plusEqualTokenEndPosition = newRoot.GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation)
-                                           .Single().Span.End;
+        var newRoot = await formattedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        var plusEqualTokenEndPosition = newRoot
+            .GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation)
+            .Single().Span.End;
 
         var newText = await formattedDocument.GetTextAsync(cancellationToken).ConfigureAwait(false);
         var newSolution = document.Project.Solution.WithDocumentText(formattedDocument.Id, newText);
 
         var finalDocument = newSolution.GetRequiredDocument(formattedDocument.Id);
-        var finalRoot = await finalDocument.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        var finalRoot = await finalDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
         var token = finalRoot.FindTokenOnRightOfPosition(plusEqualTokenEndPosition);
         var renameSpan = token.Span;
         var memberAccessExpression = token.GetAncestor<MemberAccessExpressionSyntax>();
@@ -227,7 +240,7 @@ async Task ExecuteCommandWorkerAsync()
         return (newSolution, renameSpan);
     }
 
-    private static async Task<Document> AddMethodNameAndAnnotationsToSolutionAsync(
+    private static async Task<Document?> AddMethodNameAndAnnotationsToSolutionAsync(
         Document document,
         string eventHandlerMethodName,
         int position,
@@ -235,9 +248,12 @@ private static async Task<Document> AddMethodNameAndAnnotationsToSolutionAsync(
         CancellationToken cancellationToken)
     {
         // First find the event hookup to determine if we are in a static context.
-        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
         var plusEqualsToken = root.FindTokenOnLeftOfPosition(position);
-        var eventHookupExpression = plusEqualsToken.GetAncestor<AssignmentExpressionSyntax>();
+
+        if (plusEqualsToken.Parent is not AssignmentExpressionSyntax eventHookupExpression)
+            return null;
+
         var typeDecl = eventHookupExpression.GetAncestor<TypeDeclarationSyntax>();
 
         var textToInsert = eventHandlerMethodName + ";";
@@ -250,12 +266,18 @@ private static async Task<Document> AddMethodNameAndAnnotationsToSolutionAsync(
         // Next, perform a textual insertion of the event handler method name.
         var textChange = new TextChange(new TextSpan(position, 0), textToInsert);
         var newText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
+        newText = newText.WithChanges(textChange);
         var documentWithNameAdded = document.WithText(newText);
 
         // Now find the event hookup again to add the appropriate annotations.
-        root = await documentWithNameAdded.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        root = await documentWithNameAdded.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
         plusEqualsToken = root.FindTokenOnLeftOfPosition(position);
-        eventHookupExpression = plusEqualsToken.GetAncestor<AssignmentExpressionSyntax>();
+        if (plusEqualsToken.Parent is not AssignmentExpressionSyntax)
+            return null;
+
+        eventHookupExpression = (AssignmentExpressionSyntax)plusEqualsToken.Parent;
+        if (eventHookupExpression is null)
+            return null;
 
         var updatedEventHookupExpression = eventHookupExpression
             .ReplaceToken(plusEqualsToken, plusEqualsToken.WithAdditionalAnnotations(plusEqualsTokenAnnotation))
@@ -266,7 +288,7 @@ private static async Task<Document> AddMethodNameAndAnnotationsToSolutionAsync(
         return documentWithNameAdded.WithSyntaxRoot(rootWithUpdatedEventHookupExpression);
     }
 
-    private static SyntaxNode AddGeneratedHandlerMethodToSolution(
+    private static SyntaxNode? AddGeneratedHandlerMethodToSolution(
         SemanticDocument document,
         CSharpCodeGenerationOptions options,
         string eventHandlerMethodName,
@@ -274,18 +296,18 @@ private static SyntaxNode AddGeneratedHandlerMethodToSolution(
         CancellationToken cancellationToken)
     {
         var root = document.Root;
-        var eventHookupExpression = root.GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation).Single().AsToken().GetAncestor<AssignmentExpressionSyntax>();
+        var eventHookupExpression = root
+            .GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation).Single().AsToken()
+            .GetAncestor<AssignmentExpressionSyntax>();
+        Contract.ThrowIfNull(eventHookupExpression);
 
         var typeDecl = eventHookupExpression.GetAncestor<TypeDeclarationSyntax>();
 
         var generatedMethodSymbol = GetMethodSymbol(document, eventHandlerMethodName, eventHookupExpression, cancellationToken);
-
         if (generatedMethodSymbol == null)
-        {
             return null;
-        }
 
-        var container = (SyntaxNode)typeDecl ?? eventHookupExpression.GetAncestor<CompilationUnitSyntax>();
+        var container = (SyntaxNode?)typeDecl ?? eventHookupExpression.GetAncestor<CompilationUnitSyntax>()!;
 
         var codeGenerator = document.Document.GetRequiredLanguageService<ICodeGenerationService>();
         var codeGenOptions = codeGenerator.GetInfo(new CodeGenerationContext(afterThisLocation: eventHookupExpression.GetLocation()), options, root.SyntaxTree.Options);
@@ -294,7 +316,7 @@ private static SyntaxNode AddGeneratedHandlerMethodToSolution(
         return root.ReplaceNode(container, newContainer);
     }
 
-    private static IMethodSymbol GetMethodSymbol(
+    private static IMethodSymbol? GetMethodSymbol(
         SemanticDocument semanticDocument,
         string eventHandlerMethodName,
         AssignmentExpressionSyntax eventHookupExpression,
@@ -304,20 +326,16 @@ private static IMethodSymbol GetMethodSymbol(
         var symbolInfo = semanticModel.GetSymbolInfo(eventHookupExpression.Left, cancellationToken);
 
         var symbol = symbolInfo.Symbol;
-        if (symbol == null || symbol.Kind != SymbolKind.Event)
-        {
+        if (symbol is not { Kind: SymbolKind.Event })
             return null;
-        }
 
-        var typeInference = semanticDocument.Document.GetLanguageService<ITypeInferenceService>();
+        var typeInference = semanticDocument.Document.GetRequiredLanguageService<ITypeInferenceService>();
         var delegateType = typeInference.InferDelegateType(semanticModel, eventHookupExpression.Right, cancellationToken);
-        if (delegateType == null || delegateType.DelegateInvokeMethod == null)
-        {
+        if (delegateType is not { DelegateInvokeMethod: { } delegateInvokeMethod })
             return null;
-        }
 
-        var syntaxFactory = semanticDocument.Document.GetLanguageService<SyntaxGenerator>();
-        var delegateInvokeMethod = delegateType.DelegateInvokeMethod.RemoveInaccessibleAttributesAndAttributesOfTypes(semanticDocument.SemanticModel.Compilation.Assembly);
+        var syntaxFactory = semanticDocument.Document.GetRequiredLanguageService<SyntaxGenerator>();
+        delegateInvokeMethod = delegateInvokeMethod.RemoveInaccessibleAttributesAndAttributesOfTypes(semanticDocument.SemanticModel.Compilation.Assembly);
 
         return CodeGenerationSymbolFactory.CreateMethodSymbol(
             attributes: default,
@@ -329,6 +347,6 @@ private static IMethodSymbol GetMethodSymbol(
             name: eventHandlerMethodName,
             typeParameters: default,
             parameters: delegateInvokeMethod.Parameters,
-            statements: [CodeGenerationHelpers.GenerateThrowStatement(syntaxFactory, semanticDocument, "System.NotImplementedException")]);
+            statements: [CodeGenerationHelpers.GenerateThrowStatement(syntaxFactory, semanticDocument, "System.NotImplementedException")!]);
     }
 }

From 1467b86130ed4e8bd9ac2aebe63298d5ea7a356d Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 11:43:32 -0700
Subject: [PATCH 095/170] Usings

---
 .../EventHookupCommandHandler_SessionCancellingCommands.cs       | 1 -
 .../EventHookup/EventHookupCommandHandler_TabKeyCommand.cs       | 1 -
 2 files changed, 2 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_SessionCancellingCommands.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_SessionCancellingCommands.cs
index c83b4957eea8c..4cfe306d03638 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_SessionCancellingCommands.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_SessionCancellingCommands.cs
@@ -7,7 +7,6 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.EventHookup;
 
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index 072413d23ef33..cb5e321800990 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -6,7 +6,6 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using ICSharpCode.Decompiler.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CodeCleanup;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.CodeGeneration;

From 244847f508cc7d7fe33a166efbcb364d176d5f85 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 11:50:58 -0700
Subject: [PATCH 096/170] Remove assert

---
 .../EventHookup/EventHookupCommandHandler_TabKeyCommand.cs      | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index cb5e321800990..e6cc289d1de91 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -190,8 +190,6 @@ async Task ExecuteCommandWorkerAsync()
     private async Task<(Solution solution, TextSpan renameSpan)?> TryGetNewSolutionWithAddedMethodAsync(
         Document document, string eventHandlerMethodName, int position, CancellationToken cancellationToken)
     {
-        _threadingContext.ThrowIfNotOnUIThread();
-
         // Mark the += token with an annotation so we can find it after formatting
         var plusEqualsTokenAnnotation = new SyntaxAnnotation();
 

From a453e3e449679591b310bb4ce9eec998367cb48f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 11:54:16 -0700
Subject: [PATCH 097/170] Tweak

---
 src/EditorFeatures/CSharp/CSharpEditorResources.resx          | 2 +-
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf    | 4 ++--
 src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf    | 4 ++--
 .../CSharp/xlf/CSharpEditorResources.zh-Hans.xlf              | 4 ++--
 .../CSharp/xlf/CSharpEditorResources.zh-Hant.xlf              | 4 ++--
 14 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/EditorFeatures/CSharp/CSharpEditorResources.resx b/src/EditorFeatures/CSharp/CSharpEditorResources.resx
index 84d8a5338b597..0c85188266fe5 100644
--- a/src/EditorFeatures/CSharp/CSharpEditorResources.resx
+++ b/src/EditorFeatures/CSharp/CSharpEditorResources.resx
@@ -156,6 +156,6 @@
     <value>Fixing string literal after paste</value>
   </data>
   <data name="Generating_event" xml:space="preserve">
-    <value>Generating event ...</value>
+    <value>Generating event...</value>
   </data>
 </root>
\ No newline at end of file
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
index 0ae38e09543e1..83f5df838eaf0 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.cs.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
index cde5e6b51ccf2..b514ba01c2205 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.de.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
index 7e4c5a21b43e9..f2040ac30a13a 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.es.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
index 0b48846e062d3..5140bf6b601bb 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.fr.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
index 03b937def948b..9d87f65e41bba 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.it.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
index cf524c4dc2991..663feaf7a0ce9 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ja.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
index 17bc834eae64c..38519446fcd9c 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ko.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
index 8f8ba8a4936ed..9df9db622e3ef 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pl.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
index c63add72bb5e3..034ad04abab07 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.pt-BR.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
index 803a218f49b90..8aa57ab44cc5a 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.ru.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
index 775295e1e3363..f19bbf1db2a3a 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.tr.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
index 0f69a0731b175..2fbffb81bebb9 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hans.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">
diff --git a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
index 13c0bfbb305d6..95e6024d5558d 100644
--- a/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
+++ b/src/EditorFeatures/CSharp/xlf/CSharpEditorResources.zh-Hant.xlf
@@ -33,8 +33,8 @@
         <note />
       </trans-unit>
       <trans-unit id="Generating_event">
-        <source>Generating event ...</source>
-        <target state="new">Generating event ...</target>
+        <source>Generating event...</source>
+        <target state="new">Generating event...</target>
         <note />
       </trans-unit>
       <trans-unit id="Grow_raw_string">

From f9e9b5b266a6c41b065a1e5cb8ea1691a77c65c6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 12:22:37 -0700
Subject: [PATCH 098/170] Lint

---
 .../CSharp/EventHookup/EventHookupCommandHandler.cs              | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs
index a2b546fd7fcaf..a5f814f53f0e5 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs
@@ -50,7 +50,6 @@ internal partial class EventHookupCommandHandler(
     private readonly IThreadingContext _threadingContext = threadingContext;
     private readonly IInlineRenameService _inlineRenameService = inlineRenameService;
     private readonly IAsynchronousOperationListener _asyncListener = listenerProvider.GetListener(FeatureAttribute.EventHookup);
-    private readonly IGlobalOptionService _globalOptions = globalOptions;
 
     internal readonly EventHookupSessionManager EventHookupSessionManager = eventHookupSessionManager;
 

From 383d8973462dfb14b91e3af7b2c6c61426c14bc2 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 12:43:04 -0700
Subject: [PATCH 099/170] lint

---
 .../CSharp/EventHookup/EventHookupCommandHandler.cs           | 1 +
 .../EventHookup/EventHookupCommandHandler_TabKeyCommand.cs    | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs
index a5f814f53f0e5..a2b546fd7fcaf 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs
@@ -50,6 +50,7 @@ internal partial class EventHookupCommandHandler(
     private readonly IThreadingContext _threadingContext = threadingContext;
     private readonly IInlineRenameService _inlineRenameService = inlineRenameService;
     private readonly IAsynchronousOperationListener _asyncListener = listenerProvider.GetListener(FeatureAttribute.EventHookup);
+    private readonly IGlobalOptionService _globalOptions = globalOptions;
 
     internal readonly EventHookupSessionManager EventHookupSessionManager = eventHookupSessionManager;
 
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index e6cc289d1de91..ed4f8858ed0c1 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -201,7 +201,7 @@ async Task ExecuteCommandWorkerAsync()
         var semanticDocument = await SemanticDocument.CreateAsync(
             documentWithNameAndAnnotationsAdded, cancellationToken).ConfigureAwait(false);
         var options = (CSharpCodeGenerationOptions)await document.GetCodeGenerationOptionsAsync(
-            globalOptions, cancellationToken).ConfigureAwait(false);
+            _globalOptions, cancellationToken).ConfigureAwait(false);
         var updatedRoot = AddGeneratedHandlerMethodToSolution(
             semanticDocument, options, eventHandlerMethodName, plusEqualsTokenAnnotation, cancellationToken);
 
@@ -209,7 +209,7 @@ async Task ExecuteCommandWorkerAsync()
             return null;
 
         var cleanupOptions = await documentWithNameAndAnnotationsAdded.GetCodeCleanupOptionsAsync(
-            globalOptions, cancellationToken).ConfigureAwait(false);
+            _globalOptions, cancellationToken).ConfigureAwait(false);
         var simplifiedDocument = await Simplifier.ReduceAsync(
             documentWithNameAndAnnotationsAdded.WithSyntaxRoot(updatedRoot), Simplifier.Annotation, cleanupOptions.SimplifierOptions, cancellationToken).ConfigureAwait(false);
         var formattedDocument = await Formatter.FormatAsync(

From 41d922299d61cf67c5bf2dcd963a8194e7cef484 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:13:40 -0700
Subject: [PATCH 100/170] Comment

---
 .../EventHookup/EventHookupCommandHandler_TypeCharCommand.cs  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
index 659d21c00a87f..e50aa4f5f6be2 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
@@ -62,10 +62,10 @@ private bool IsTextualPlusEquals(ITextView textView, ITextBuffer subjectBuffer)
 
         var caretPoint = textView.GetCaretPoint(subjectBuffer);
         if (!caretPoint.HasValue)
-        {
             return false;
-        }
 
+        // Check that we're directly after `+=` in the source text.  Later passed will ensure we're actually in an
+        // appropriate syntax and semantic context.
         var position = caretPoint.Value.Position;
         return position - 2 >= 0 &&
             subjectBuffer.CurrentSnapshot[position - 1] == '=' &&

From 6bdcef6106185b94f465795d15ea7fda247863b5 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:15:01 -0700
Subject: [PATCH 101/170] Remove unused method

---
 .../CSharp/EventHookup/EventHookupSessionManager.cs           | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
index 24b98f380f813..0091fd45db20a 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
@@ -182,8 +182,4 @@ private void Caret_PositionChanged(object sender, EventArgs e)
             CancelAndDismissExistingSessions();
         }
     }
-
-    [MemberNotNullWhen(true, nameof(CurrentSession))]
-    internal bool IsTrackingSession()
-        => CurrentSession != null;
 }

From 9e71c1b7574fd00eb52b0e13c03766ba01292c09 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:17:06 -0700
Subject: [PATCH 102/170] Remove checks

---
 .../EventHookup/EventHookupCommandHandler_TabKeyCommand.cs     | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index ed4f8858ed0c1..ece28be8f435d 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -159,7 +159,6 @@ async Task ExecuteCommandWorkerAsync()
 
             // switch back to the UI thread.
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-            _threadingContext.ThrowIfNotOnUIThread();
 
             // If anything changed in the view between computation and application, bail out.
             if (solutionAndRenameSpan is null ||
@@ -174,8 +173,6 @@ async Task ExecuteCommandWorkerAsync()
             var workspace = document.Project.Solution.Workspace;
             if (workspace.TryApplyChanges(solutionWithEventHandler))
             {
-                _threadingContext.ThrowIfNotOnUIThread();
-
                 if (_inlineRenameService.ActiveSession is null)
                 {
                     var updatedDocument = workspace.CurrentSolution.GetRequiredDocument(document.Id);

From cfb756d2a34ef1a0be12b6e3136f5ee7f688ca4a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:33:53 -0700
Subject: [PATCH 103/170] Cleanup

---
 ...ommandHandler_SessionCancellingCommands.cs |   2 +-
 ...EventHookupCommandHandler_TabKeyCommand.cs |  23 +++-
 ...entHookupCommandHandler_TypeCharCommand.cs |  24 ++--
 .../EventHookup/EventHookupSessionManager.cs  |  26 ++--
 ...HookupSessionManager_EventHookupSession.cs | 125 +++++++++---------
 5 files changed, 111 insertions(+), 89 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_SessionCancellingCommands.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_SessionCancellingCommands.cs
index 4cfe306d03638..50f67cf7bd091 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_SessionCancellingCommands.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_SessionCancellingCommands.cs
@@ -18,7 +18,7 @@ internal partial class EventHookupCommandHandler :
     public bool ExecuteCommand(EscapeKeyCommandArgs args, CommandExecutionContext context)
     {
         _threadingContext.ThrowIfNotOnUIThread();
-        EventHookupSessionManager.CancelAndDismissExistingSessions();
+        EventHookupSessionManager.DismissExistingSessions();
         return false;
     }
 
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index ece28be8f435d..92cca78c17f91 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -52,7 +52,7 @@ public void ExecuteCommand(TabKeyCommandArgs args, Action nextHandler, CommandEx
         if (!TryExecuteCommand(args, nextHandler))
         {
             // If we didn't process this tag to emit an event handler, just pass the tab through to the buffer normally.
-            EventHookupSessionManager.DismissExistingSessions(cancelBackgroundTasks: true);
+            EventHookupSessionManager.DismissExistingSessions();
             nextHandler();
         }
     }
@@ -93,12 +93,12 @@ private bool TryExecuteCommand(TabKeyCommandArgs args, Action nextHandler)
 
         // Capture everything we need off of the session manager as we'll be dismissing the core session immediately
         // before we kick off the work to emit hte event.
-        var eventNameTask = EventHookupSessionManager.CurrentSession.GetEventNameTask;
+        var (eventNameTask, eventNameTokenSource) = EventHookupSessionManager.CurrentSession.DetachEventNameTask();
         var applicableToSpan = EventHookupSessionManager.CurrentSession.TrackingSpan.GetSpan(currentSnapshot);
 
         // Ensure no matter what that once tab is hit that we're back to the initial no-session state. We do not
         // want to cancel the bg tasks kicked off as we need their values to actually emit the event.
-        EventHookupSessionManager.DismissExistingSessions(cancelBackgroundTasks: false);
+        EventHookupSessionManager.DismissExistingSessions();
 
         var task = ExecuteCommandAsync(
             args,
@@ -106,6 +106,7 @@ private bool TryExecuteCommand(TabKeyCommandArgs args, Action nextHandler)
             applicableToSpan,
             document,
             eventNameTask,
+            eventNameTokenSource,
             caretPoint.Value);
         task.CompletesAsyncOperation(token);
 
@@ -119,7 +120,8 @@ private async Task ExecuteCommandAsync(
         Action nextHandler,
         SnapshotSpan applicableToSpan,
         Document document,
-        Task<string> getEventNameTask,
+        Task<string?> eventNameTask,
+        CancellationTokenSource eventNameCancellationTokenSource,
         SnapshotPoint initialCaretPoint)
     {
         try
@@ -133,6 +135,12 @@ private async Task ExecuteCommandAsync(
         catch (Exception ex) when (FatalError.ReportAndCatch(ex))
         {
         }
+        finally
+        {
+            // Once we finish doing our own work (including potentially cancelling out), ensure that any BG worked
+            // kicked off to compute the event name is canceled as well so it doesn't keep consuming resources.
+            eventNameCancellationTokenSource.Cancel();
+        }
 
         return;
 
@@ -149,7 +157,12 @@ async Task ExecuteCommandWorkerAsync()
 
             var cancellationToken = waitContext.UserCancellationToken;
 
-            var eventHandlerMethodName = await getEventNameTask.WithCancellation(cancellationToken).ConfigureAwait(false);
+            var eventHandlerMethodName = await eventNameTask.WithCancellation(cancellationToken).ConfigureAwait(false);
+            if (eventHandlerMethodName is null)
+            {
+                nextHandler();
+                return;
+            }
 
             var solutionAndRenameSpan = await TryGetNewSolutionWithAddedMethodAsync(
                 document, eventHandlerMethodName, initialCaretPoint.Position, cancellationToken).ConfigureAwait(false);
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
index e50aa4f5f6be2..f447133de01bc 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs
@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.EventHookup;
 using Microsoft.CodeAnalysis.Internal.Log;
+using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
@@ -25,7 +26,7 @@ public void ExecuteCommand(TypeCharCommandArgs args, Action nextHandler, Command
 
         if (!_globalOptions.GetOption(EventHookupOptionsStorage.EventHookup))
         {
-            EventHookupSessionManager.CancelAndDismissExistingSessions();
+            EventHookupSessionManager.DismissExistingSessions();
             return;
         }
 
@@ -38,20 +39,27 @@ public void ExecuteCommand(TypeCharCommandArgs args, Action nextHandler, Command
                 // They've typed an equals. Cancel existing sessions and potentially start a 
                 // new session.
 
-                EventHookupSessionManager.CancelAndDismissExistingSessions();
+                EventHookupSessionManager.DismissExistingSessions();
 
                 if (IsTextualPlusEquals(args.TextView, args.SubjectBuffer))
                 {
-                    EventHookupSessionManager.BeginSession(this, args.TextView, args.SubjectBuffer, _asyncListener, TESTSessionHookupMutex);
+                    var caretPosition = args.TextView.GetCaretPoint(args.SubjectBuffer);
+                    if (caretPosition != null)
+                    {
+                        var document = args.SubjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges();
+                        if (document != null && document.Project.Solution.Workspace.CanApplyChange(ApplyChangesKind.ChangeDocument))
+                        {
+                            EventHookupSessionManager.BeginSession(
+                                this, args.TextView, args.SubjectBuffer, caretPosition.Value.Position,
+                                document, _asyncListener, TESTSessionHookupMutex);
+                        }
+                    }
                 }
             }
-            else
+            else if (args.TypedChar != ' ')
             {
                 // Spaces are the only non-'=' character that allow the session to continue
-                if (args.TypedChar != ' ')
-                {
-                    EventHookupSessionManager.CancelAndDismissExistingSessions();
-                }
+                EventHookupSessionManager.DismissExistingSessions();
             }
         }
     }
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
index 0091fd45db20a..5b1890636f6f0 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
@@ -40,7 +40,7 @@ internal sealed partial class EventHookupSessionManager(
     // For test purposes only!
     internal ClassifiedTextElement[] TEST_MostRecentToolTipContent { get; set; }
 
-    internal void EventHookupFoundInSession(EventHookupSession analyzedSession)
+    internal void EventHookupFoundInSession(EventHookupSession analyzedSession, string eventName)
     {
         ThreadingContext.ThrowIfNotOnUIThread();
 
@@ -62,7 +62,7 @@ internal void EventHookupFoundInSession(EventHookupSession analyzedSession)
             // GetEventNameTask() gets back the event name, only needs to add a semicolon after it.
             var textRuns = new[]
             {
-                new ClassifiedTextRun(ClassificationTypeNames.MethodName, analyzedSession.GetEventNameTask.Result, ClassifiedTextRunStyle.UseClassificationFont),
+                new ClassifiedTextRun(ClassificationTypeNames.MethodName, eventName, ClassifiedTextRunStyle.UseClassificationFont),
                 new ClassifiedTextRun(ClassificationTypeNames.Punctuation, ";", ClassifiedTextRunStyle.UseClassificationFont),
                 new ClassifiedTextRun(ClassificationTypeNames.Text, CSharpEditorResources.Press_TAB_to_insert),
             };
@@ -108,16 +108,16 @@ internal void BeginSession(
         EventHookupCommandHandler eventHookupCommandHandler,
         ITextView textView,
         ITextBuffer subjectBuffer,
+        int position,
+        Document document,
         IAsynchronousOperationListener asyncListener,
         Mutex testSessionHookupMutex)
     {
-        CurrentSession = new EventHookupSession(this, eventHookupCommandHandler, textView, subjectBuffer, asyncListener, _globalOptions, testSessionHookupMutex);
+        CurrentSession = new EventHookupSession(
+            this, eventHookupCommandHandler, textView, subjectBuffer, position, document, asyncListener, _globalOptions, testSessionHookupMutex);
     }
 
-    public void CancelAndDismissExistingSessions()
-        => DismissExistingSessions(cancelBackgroundTasks: true);
-
-    public void DismissExistingSessions(bool cancelBackgroundTasks)
+    public void DismissExistingSessions()
     {
         ThreadingContext.ThrowIfNotOnUIThread();
 
@@ -129,9 +129,7 @@ public void DismissExistingSessions(bool cancelBackgroundTasks)
 
         if (CurrentSession != null)
         {
-            if (cancelBackgroundTasks)
-                CurrentSession.CancelBackgroundTasks();
-
+            CurrentSession.CancelBackgroundTasks();
             CurrentSession = null;
         }
 
@@ -150,7 +148,7 @@ private void TextBuffer_Changed(object sender, TextContentChangedEventArgs e)
         {
             if (change.OldText.Length > 0 || change.NewText.Any(c => c != ' '))
             {
-                CancelAndDismissExistingSessions();
+                DismissExistingSessions();
                 return;
             }
         }
@@ -165,7 +163,7 @@ private void Caret_PositionChanged(object sender, EventArgs e)
 
         if (CurrentSession == null)
         {
-            CancelAndDismissExistingSessions();
+            DismissExistingSessions();
             return;
         }
 
@@ -173,13 +171,13 @@ private void Caret_PositionChanged(object sender, EventArgs e)
 
         if (!caretPoint.HasValue)
         {
-            CancelAndDismissExistingSessions();
+            DismissExistingSessions();
         }
 
         var snapshotSpan = CurrentSession.TrackingSpan.GetSpan(CurrentSession.TextView.TextSnapshot);
         if (snapshotSpan.Snapshot != caretPoint.Value.Snapshot || !snapshotSpan.Contains(caretPoint.Value))
         {
-            CancelAndDismissExistingSessions();
+            DismissExistingSessions();
         }
     }
 }
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
index c6bdecf6f766b..a974cb7858f08 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
@@ -2,10 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -16,7 +13,6 @@
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
-using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.LanguageService;
 using Microsoft.CodeAnalysis.Options;
@@ -40,9 +36,7 @@ internal sealed partial class EventHookupSessionManager
     /// </summary>
     internal class EventHookupSession
     {
-        public readonly Task<string> GetEventNameTask;
         private readonly IThreadingContext _threadingContext;
-        private readonly CancellationTokenSource _cancellationTokenSource = new();
         private readonly ITrackingPoint _trackingPoint;
         private readonly ITrackingSpan _trackingSpan;
         private readonly ITextView _textView;
@@ -52,7 +46,10 @@ internal class EventHookupSession
         public event Action Dismissed = () => { };
 
         // For testing purposes only! Should always be null except in tests.
-        internal Mutex TESTSessionHookupMutex = null;
+        internal Mutex? TESTSessionHookupMutex = null;
+
+        private Task<string?>? _eventNameTask;
+        private CancellationTokenSource? _cancellationTokenSource;
 
         public ITrackingPoint TrackingPoint
         {
@@ -93,7 +90,7 @@ public ITextBuffer SubjectBuffer
         public void CancelBackgroundTasks()
         {
             _threadingContext.ThrowIfNotOnUIThread();
-            _cancellationTokenSource.Cancel();
+            _cancellationTokenSource?.Cancel();
         }
 
         public EventHookupSession(
@@ -101,61 +98,69 @@ public EventHookupSession(
             EventHookupCommandHandler commandHandler,
             ITextView textView,
             ITextBuffer subjectBuffer,
+            int position,
+            Document document,
             IAsynchronousOperationListener asyncListener,
             IGlobalOptionService globalOptions,
             Mutex testSessionHookupMutex)
         {
             _threadingContext = eventHookupSessionManager.ThreadingContext;
+            _threadingContext.ThrowIfNotOnUIThread();
+
+            _cancellationTokenSource = new();
             var cancellationToken = _cancellationTokenSource.Token;
             _textView = textView;
             _subjectBuffer = subjectBuffer;
             _globalOptions = globalOptions;
             this.TESTSessionHookupMutex = testSessionHookupMutex;
 
-            var document = textView.TextSnapshot.GetOpenDocumentInCurrentContextWithChanges();
-            var workspace = textView.TextSnapshot.TextBuffer.GetWorkspace();
-            if (document != null && workspace != null && workspace.CanApplyChange(ApplyChangesKind.ChangeDocument))
-            {
-                var position = textView.GetCaretPoint(subjectBuffer).Value.Position;
-                _trackingPoint = textView.TextSnapshot.CreateTrackingPoint(position, PointTrackingMode.Negative);
+            _trackingPoint = textView.TextSnapshot.CreateTrackingPoint(position, PointTrackingMode.Negative);
+
+            // If the caret is at the end of the document we just create an empty span
+            var length = textView.TextSnapshot.Length > position + 1 ? 1 : 0;
+            _trackingSpan = textView.TextSnapshot.CreateTrackingSpan(new Span(position, length), SpanTrackingMode.EdgeInclusive);
 
-                // If the caret is at the end of the document we just create an empty span
-                var length = textView.TextSnapshot.Length > position + 1 ? 1 : 0;
-                _trackingSpan = textView.TextSnapshot.CreateTrackingSpan(new Span(position, length), SpanTrackingMode.EdgeInclusive);
+            var asyncToken = asyncListener.BeginAsyncOperation(GetType().Name + ".Start");
 
-                var asyncToken = asyncListener.BeginAsyncOperation(GetType().Name + ".Start");
+            _eventNameTask = Task.Factory.SafeStartNewFromAsync(
+                () => DetermineIfEventHookupAndGetHandlerNameAsync(document, position, cancellationToken),
+                cancellationToken,
+                TaskScheduler.Default);
 
-                this.GetEventNameTask = Task.Factory.SafeStartNewFromAsync(
-                    () => DetermineIfEventHookupAndGetHandlerNameAsync(document, position, cancellationToken),
-                    cancellationToken,
-                    TaskScheduler.Default);
+            var continuedTask = _eventNameTask.SafeContinueWithFromAsync(
+                async t =>
+                {
+                    await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, cancellationToken);
 
-                var continuedTask = this.GetEventNameTask.SafeContinueWithFromAsync(
-                    async t =>
+                    if (t.Result != null)
                     {
-                        await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, cancellationToken);
-
-                        if (t.Result != null)
-                        {
-                            commandHandler.EventHookupSessionManager.EventHookupFoundInSession(this);
-                        }
-                    },
-                    cancellationToken,
-                    TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously,
-                    TaskScheduler.Default);
-
-                continuedTask.CompletesAsyncOperation(asyncToken);
-            }
-            else
-            {
-                _trackingPoint = textView.TextSnapshot.CreateTrackingPoint(0, PointTrackingMode.Negative);
-                _trackingSpan = textView.TextSnapshot.CreateTrackingSpan(new Span(), SpanTrackingMode.EdgeInclusive);
-                this.GetEventNameTask = SpecializedTasks.Null<string>();
-                eventHookupSessionManager.CancelAndDismissExistingSessions();
-            }
+                        commandHandler.EventHookupSessionManager.EventHookupFoundInSession(this, t.Result);
+                    }
+                },
+                cancellationToken,
+                TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously,
+                TaskScheduler.Default);
+
+            continuedTask.CompletesAsyncOperation(asyncToken);
         }
 
-        private async Task<string> DetermineIfEventHookupAndGetHandlerNameAsync(Document document, int position, CancellationToken cancellationToken)
+        public (Task<string?> eventNameTask, CancellationTokenSource cancellationTokenSource) DetachEventNameTask()
+        {
+            _threadingContext.ThrowIfNotOnBackgroundThread();
+
+            Contract.ThrowIfNull(_eventNameTask);
+            Contract.ThrowIfNull(_cancellationTokenSource);
+
+            var eventNameTask = _eventNameTask;
+            var cancellationTokenSource = _cancellationTokenSource;
+
+            _eventNameTask = null;
+            _cancellationTokenSource = null;
+
+            return (eventNameTask, cancellationTokenSource);
+        }
+
+        private async Task<string?> DetermineIfEventHookupAndGetHandlerNameAsync(Document document, int position, CancellationToken cancellationToken)
         {
             _threadingContext.ThrowIfNotOnBackgroundThread();
 
@@ -174,7 +179,7 @@ private async Task<string> DetermineIfEventHookupAndGetHandlerNameAsync(Document
                     return null;
                 }
 
-                var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
                 var eventSymbol = GetEventSymbol(semanticModel, plusEqualsToken.Value, cancellationToken);
                 if (eventSymbol == null)
@@ -184,21 +189,21 @@ private async Task<string> DetermineIfEventHookupAndGetHandlerNameAsync(Document
 
                 var namingRule = await document.GetApplicableNamingRuleAsync(
                     new SymbolKindOrTypeKind(MethodKind.Ordinary),
-                    new DeclarationModifiers(isStatic: plusEqualsToken.Value.Parent.IsInStaticContext()),
+                    new DeclarationModifiers(isStatic: plusEqualsToken.Value.GetRequiredParent().IsInStaticContext()),
                     Accessibility.Private,
                     _globalOptions.CreateProvider(),
                     cancellationToken).ConfigureAwait(false);
 
                 return GetEventHandlerName(
                     eventSymbol, plusEqualsToken.Value, semanticModel,
-                    document.GetLanguageService<ISyntaxFactsService>(), namingRule);
+                    document.GetRequiredLanguageService<ISyntaxFactsService>(), namingRule);
             }
         }
 
         private async Task<SyntaxToken?> GetPlusEqualsTokenInsideAddAssignExpressionAsync(Document document, int position, CancellationToken cancellationToken)
         {
             _threadingContext.ThrowIfNotOnBackgroundThread();
-            var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+            var syntaxTree = await document.GetRequiredSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
             var token = syntaxTree.FindTokenOnLeftOfPosition(position, cancellationToken);
 
             if (token.Kind() != SyntaxKind.PlusEqualsToken)
@@ -214,7 +219,7 @@ private async Task<string> DetermineIfEventHookupAndGetHandlerNameAsync(Document
             return token;
         }
 
-        private IEventSymbol GetEventSymbol(SemanticModel semanticModel, SyntaxToken plusEqualsToken, CancellationToken cancellationToken)
+        private IEventSymbol? GetEventSymbol(SemanticModel semanticModel, SyntaxToken plusEqualsToken, CancellationToken cancellationToken)
         {
             _threadingContext.ThrowIfNotOnBackgroundThread();
             if (plusEqualsToken.Parent is not AssignmentExpressionSyntax parentToken)
@@ -222,21 +227,18 @@ private IEventSymbol GetEventSymbol(SemanticModel semanticModel, SyntaxToken plu
                 return null;
             }
 
-            var symbol = semanticModel.GetSymbolInfo(parentToken.Left, cancellationToken).Symbol;
-            if (symbol == null)
-            {
-                return null;
-            }
-
-            return symbol as IEventSymbol;
+            return semanticModel.GetSymbolInfo(parentToken.Left, cancellationToken).Symbol as IEventSymbol;
         }
 
-        private string GetEventHandlerName(
+        private string? GetEventHandlerName(
             IEventSymbol eventSymbol, SyntaxToken plusEqualsToken, SemanticModel semanticModel,
             ISyntaxFactsService syntaxFactsService, NamingRule namingRule)
         {
             _threadingContext.ThrowIfNotOnBackgroundThread();
             var objectPart = GetNameObjectPart(eventSymbol, plusEqualsToken, semanticModel, syntaxFactsService);
+            if (objectPart is null)
+                return null;
+
             var basename = namingRule.NamingStyle.CreateName([string.Format("{0}_{1}", objectPart, eventSymbol.Name)]);
 
             var reservedNames = semanticModel.LookupSymbols(plusEqualsToken.SpanStart).Select(m => m.Name);
@@ -252,12 +254,13 @@ private string GetEventHandlerName(
         /// 'button1' and 'listBox1' respectively. If the field belongs to 'this', then we use
         /// the name of this class, as we do if we can't make any sense out of the parse tree.
         /// </summary>
-        private string GetNameObjectPart(IEventSymbol eventSymbol, SyntaxToken plusEqualsToken, SemanticModel semanticModel, ISyntaxFactsService syntaxFactsService)
+        private string? GetNameObjectPart(IEventSymbol eventSymbol, SyntaxToken plusEqualsToken, SemanticModel semanticModel, ISyntaxFactsService syntaxFactsService)
         {
             _threadingContext.ThrowIfNotOnBackgroundThread();
-            var parentToken = plusEqualsToken.Parent as AssignmentExpressionSyntax;
+            if (plusEqualsToken.Parent is not AssignmentExpressionSyntax assignmentExpression)
+                return null;
 
-            if (parentToken.Left is MemberAccessExpressionSyntax memberAccessExpression)
+            if (assignmentExpression.Left is MemberAccessExpressionSyntax memberAccessExpression)
             {
                 // This is expected -- it means the last thing is(probably) the event name. We 
                 // already have that in eventSymbol. What we need is the LHS of that dot.

From 4657126ef5c8662740f3219810e3081db9409f4d Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:34:55 -0700
Subject: [PATCH 104/170] Detach later

---
 .../EventHookup/EventHookupCommandHandler_TabKeyCommand.cs  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index 92cca78c17f91..90e05ea7f45f2 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -167,9 +167,6 @@ async Task ExecuteCommandWorkerAsync()
             var solutionAndRenameSpan = await TryGetNewSolutionWithAddedMethodAsync(
                 document, eventHandlerMethodName, initialCaretPoint.Position, cancellationToken).ConfigureAwait(false);
 
-            // We're about to make an edit ourselves.  so disable the cancellation that happens on editing.
-            waitContext.CancelOnEdit = false;
-
             // switch back to the UI thread.
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
@@ -182,6 +179,9 @@ async Task ExecuteCommandWorkerAsync()
                 return;
             }
 
+            // We're about to make an edit ourselves.  so disable the cancellation that happens on editing.
+            waitContext.CancelOnEdit = false;
+
             var (solutionWithEventHandler, renameSpan) = solutionAndRenameSpan.Value;
             var workspace = document.Project.Solution.Workspace;
             if (workspace.TryApplyChanges(solutionWithEventHandler))

From 3668aa91bba635d9a84be8510261e3859898f509 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:42:55 -0700
Subject: [PATCH 105/170] Error paths

---
 ...EventHookupCommandHandler_TabKeyCommand.cs | 66 +++++++++++--------
 1 file changed, 38 insertions(+), 28 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index 90e05ea7f45f2..f354809b17506 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -51,10 +51,12 @@ public void ExecuteCommand(TabKeyCommandArgs args, Action nextHandler, CommandEx
         _threadingContext.ThrowIfNotOnUIThread();
         if (!TryExecuteCommand(args, nextHandler))
         {
-            // If we didn't process this tag to emit an event handler, just pass the tab through to the buffer normally.
-            EventHookupSessionManager.DismissExistingSessions();
             nextHandler();
         }
+
+        // We always dismiss the tracking session once a tab has gone through.  Either we didn't handle it (and
+        // nextHandler was called above).  Or we did handle it, in which case the bg async work owns the experience now.
+        EventHookupSessionManager.DismissExistingSessions();
     }
 
     private bool TryExecuteCommand(TabKeyCommandArgs args, Action nextHandler)
@@ -92,14 +94,11 @@ private bool TryExecuteCommand(TabKeyCommandArgs args, Action nextHandler)
         var token = _asyncListener.BeginAsyncOperation(nameof(ExecuteCommand));
 
         // Capture everything we need off of the session manager as we'll be dismissing the core session immediately
-        // before we kick off the work to emit hte event.
+        // before we kick off the work to emit hte event.  Detach the bg work that was already kicked off so that we
+        // own its lifetime from now on.
         var (eventNameTask, eventNameTokenSource) = EventHookupSessionManager.CurrentSession.DetachEventNameTask();
         var applicableToSpan = EventHookupSessionManager.CurrentSession.TrackingSpan.GetSpan(currentSnapshot);
 
-        // Ensure no matter what that once tab is hit that we're back to the initial no-session state. We do not
-        // want to cancel the bg tasks kicked off as we need their values to actually emit the event.
-        EventHookupSessionManager.DismissExistingSessions();
-
         var task = ExecuteCommandAsync(
             args,
             nextHandler,
@@ -124,10 +123,24 @@ private async Task ExecuteCommandAsync(
         CancellationTokenSource eventNameCancellationTokenSource,
         SnapshotPoint initialCaretPoint)
     {
+        var textView = args.TextView;
+        var subjectBuffer = args.SubjectBuffer;
+
+        // Don't want any exceptions bubble up from this point on (they have no where to go since we effectively did a
+        // fire-and-forget).  So we instead handle things ourselves, reporting NFWs if unforseen things happened.
         try
         {
-            _threadingContext.ThrowIfNotOnUIThread();
-            await ExecuteCommandWorkerAsync().ConfigureAwait(false);
+            if (!await ExecuteCommandWorkerAsync().ConfigureAwait(true))
+            {
+                // We didn't successfully handle the command.  If no other changes have gotten through in the mean time,
+                // then attempt to send the tab through to the editor.  If other changes went through, don't send the
+                // tab through as it's likely to make things worse.
+                if (applicableToSpan.Snapshot.Version == subjectBuffer.CurrentSnapshot.Version &&
+                    textView.GetCaretPoint(subjectBuffer) != initialCaretPoint)
+                {
+                    nextHandler();
+                }
+            }
         }
         catch (OperationCanceledException)
         {
@@ -144,10 +157,9 @@ private async Task ExecuteCommandAsync(
 
         return;
 
-        async Task ExecuteCommandWorkerAsync()
+        async Task<bool> ExecuteCommandWorkerAsync()
         {
-            var textView = args.TextView;
-            var subjectBuffer = args.SubjectBuffer;
+            _threadingContext.ThrowIfNotOnUIThread();
 
             var factory = document.Project.Solution.Workspace.Services.GetRequiredService<IBackgroundWorkIndicatorFactory>();
             using var waitContext = factory.Create(
@@ -159,24 +171,21 @@ async Task ExecuteCommandWorkerAsync()
 
             var eventHandlerMethodName = await eventNameTask.WithCancellation(cancellationToken).ConfigureAwait(false);
             if (eventHandlerMethodName is null)
-            {
-                nextHandler();
-                return;
-            }
+                return false;
 
             var solutionAndRenameSpan = await TryGetNewSolutionWithAddedMethodAsync(
                 document, eventHandlerMethodName, initialCaretPoint.Position, cancellationToken).ConfigureAwait(false);
+            if (solutionAndRenameSpan is null)
+                return false;
 
             // switch back to the UI thread.
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             // If anything changed in the view between computation and application, bail out.
-            if (solutionAndRenameSpan is null ||
-                applicableToSpan.Snapshot.Version != subjectBuffer.CurrentSnapshot.Version ||
+            if (applicableToSpan.Snapshot.Version != subjectBuffer.CurrentSnapshot.Version ||
                 textView.GetCaretPoint(subjectBuffer) != initialCaretPoint)
             {
-                nextHandler();
-                return;
+                return false;
             }
 
             // We're about to make an edit ourselves.  so disable the cancellation that happens on editing.
@@ -184,16 +193,17 @@ async Task ExecuteCommandWorkerAsync()
 
             var (solutionWithEventHandler, renameSpan) = solutionAndRenameSpan.Value;
             var workspace = document.Project.Solution.Workspace;
-            if (workspace.TryApplyChanges(solutionWithEventHandler))
-            {
-                if (_inlineRenameService.ActiveSession is null)
-                {
-                    var updatedDocument = workspace.CurrentSolution.GetRequiredDocument(document.Id);
-                    _inlineRenameService.StartInlineSession(updatedDocument, renameSpan, cancellationToken);
-                }
+            if (!workspace.TryApplyChanges(solutionWithEventHandler))
+                return false;
 
-                textView.SetSelection(renameSpan.ToSnapshotSpan(subjectBuffer.CurrentSnapshot));
+            if (_inlineRenameService.ActiveSession is null)
+            {
+                var updatedDocument = workspace.CurrentSolution.GetRequiredDocument(document.Id);
+                _inlineRenameService.StartInlineSession(updatedDocument, renameSpan, cancellationToken);
             }
+
+            textView.SetSelection(renameSpan.ToSnapshotSpan(subjectBuffer.CurrentSnapshot));
+            return true;
         }
     }
 

From 6bf26cf8ad18d6a348b9d1423c397ed9490e53d0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:44:18 -0700
Subject: [PATCH 106/170] Rename

---
 .../EventHookup/EventHookupCommandHandler_TabKeyCommand.cs  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index f354809b17506..5c37ea67ce369 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -130,7 +130,7 @@ private async Task ExecuteCommandAsync(
         // fire-and-forget).  So we instead handle things ourselves, reporting NFWs if unforseen things happened.
         try
         {
-            if (!await ExecuteCommandWorkerAsync().ConfigureAwait(true))
+            if (!await TryExecuteCommandAsync().ConfigureAwait(true))
             {
                 // We didn't successfully handle the command.  If no other changes have gotten through in the mean time,
                 // then attempt to send the tab through to the editor.  If other changes went through, don't send the
@@ -157,7 +157,7 @@ private async Task ExecuteCommandAsync(
 
         return;
 
-        async Task<bool> ExecuteCommandWorkerAsync()
+        async Task<bool> TryExecuteCommandAsync()
         {
             _threadingContext.ThrowIfNotOnUIThread();
 
@@ -178,7 +178,7 @@ async Task<bool> ExecuteCommandWorkerAsync()
             if (solutionAndRenameSpan is null)
                 return false;
 
-            // switch back to the UI thread.
+            // switch back to the UI thread to now apply the change.
             await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
 
             // If anything changed in the view between computation and application, bail out.

From 1453e39eeae35b9ad0cb90e6e77e85f453441e0a Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:44:57 -0700
Subject: [PATCH 107/170] Simplify

---
 .../EventHookup/EventHookupCommandHandler_TabKeyCommand.cs    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index 5c37ea67ce369..080f8babb34b1 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -191,11 +191,11 @@ async Task<bool> TryExecuteCommandAsync()
             // We're about to make an edit ourselves.  so disable the cancellation that happens on editing.
             waitContext.CancelOnEdit = false;
 
-            var (solutionWithEventHandler, renameSpan) = solutionAndRenameSpan.Value;
             var workspace = document.Project.Solution.Workspace;
-            if (!workspace.TryApplyChanges(solutionWithEventHandler))
+            if (!workspace.TryApplyChanges(solutionAndRenameSpan.Value.solution))
                 return false;
 
+            var renameSpan = solutionAndRenameSpan.Value.renameSpan;
             if (_inlineRenameService.ActiveSession is null)
             {
                 var updatedDocument = workspace.CurrentSolution.GetRequiredDocument(document.Id);

From c9f8dd93b76be06fa0abe5720d097beba8c9d956 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Mon, 18 Mar 2024 13:46:02 -0700
Subject: [PATCH 108/170] Make static

---
 .../EventHookupCommandHandler_TabKeyCommand.cs   | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index 080f8babb34b1..f6947aefe7546 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -33,6 +33,8 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.EventHookup;
 
 internal partial class EventHookupCommandHandler : IChainedCommandHandler<TabKeyCommandArgs>
 {
+    private static readonly SyntaxAnnotation s_plusEqualsTokenAnnotation = new();
+
     public CommandState GetCommandState(TabKeyCommandArgs args, Func<CommandState> nextHandler)
     {
         _threadingContext.ThrowIfNotOnUIThread();
@@ -211,10 +213,8 @@ async Task<bool> TryExecuteCommandAsync()
         Document document, string eventHandlerMethodName, int position, CancellationToken cancellationToken)
     {
         // Mark the += token with an annotation so we can find it after formatting
-        var plusEqualsTokenAnnotation = new SyntaxAnnotation();
-
         var documentWithNameAndAnnotationsAdded = await AddMethodNameAndAnnotationsToSolutionAsync(
-            document, eventHandlerMethodName, position, plusEqualsTokenAnnotation, cancellationToken).ConfigureAwait(false);
+            document, eventHandlerMethodName, position, cancellationToken).ConfigureAwait(false);
         if (documentWithNameAndAnnotationsAdded is null)
             return null;
 
@@ -223,7 +223,7 @@ async Task<bool> TryExecuteCommandAsync()
         var options = (CSharpCodeGenerationOptions)await document.GetCodeGenerationOptionsAsync(
             _globalOptions, cancellationToken).ConfigureAwait(false);
         var updatedRoot = AddGeneratedHandlerMethodToSolution(
-            semanticDocument, options, eventHandlerMethodName, plusEqualsTokenAnnotation, cancellationToken);
+            semanticDocument, options, eventHandlerMethodName, cancellationToken);
 
         if (updatedRoot == null)
             return null;
@@ -237,7 +237,7 @@ async Task<bool> TryExecuteCommandAsync()
 
         var newRoot = await formattedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
         var plusEqualTokenEndPosition = newRoot
-            .GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation)
+            .GetAnnotatedNodesAndTokens(s_plusEqualsTokenAnnotation)
             .Single().Span.End;
 
         var newText = await formattedDocument.GetTextAsync(cancellationToken).ConfigureAwait(false);
@@ -261,7 +261,6 @@ async Task<bool> TryExecuteCommandAsync()
         Document document,
         string eventHandlerMethodName,
         int position,
-        SyntaxAnnotation plusEqualsTokenAnnotation,
         CancellationToken cancellationToken)
     {
         // First find the event hookup to determine if we are in a static context.
@@ -297,7 +296,7 @@ async Task<bool> TryExecuteCommandAsync()
             return null;
 
         var updatedEventHookupExpression = eventHookupExpression
-            .ReplaceToken(plusEqualsToken, plusEqualsToken.WithAdditionalAnnotations(plusEqualsTokenAnnotation))
+            .ReplaceToken(plusEqualsToken, plusEqualsToken.WithAdditionalAnnotations(s_plusEqualsTokenAnnotation))
             .WithRight(eventHookupExpression.Right.WithAdditionalAnnotations(Simplifier.Annotation))
             .WithAdditionalAnnotations(Formatter.Annotation);
 
@@ -309,12 +308,11 @@ async Task<bool> TryExecuteCommandAsync()
         SemanticDocument document,
         CSharpCodeGenerationOptions options,
         string eventHandlerMethodName,
-        SyntaxAnnotation plusEqualsTokenAnnotation,
         CancellationToken cancellationToken)
     {
         var root = document.Root;
         var eventHookupExpression = root
-            .GetAnnotatedNodesAndTokens(plusEqualsTokenAnnotation).Single().AsToken()
+            .GetAnnotatedNodesAndTokens(s_plusEqualsTokenAnnotation).Single().AsToken()
             .GetAncestor<AssignmentExpressionSyntax>();
         Contract.ThrowIfNull(eventHookupExpression);
 

From 765141d4050840553e00541aa587cb033d17f0ec Mon Sep 17 00:00:00 2001
From: Andrew Hall <andrha@microsoft.com>
Date: Mon, 18 Mar 2024 14:23:03 -0700
Subject: [PATCH 109/170] Bump razor EA version to accomodate serialization
 version bump (#72575)

---
 eng/Directory.Packages.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/Directory.Packages.props b/eng/Directory.Packages.props
index 44f9452dad04e..97b6a820a7560 100644
--- a/eng/Directory.Packages.props
+++ b/eng/Directory.Packages.props
@@ -141,7 +141,7 @@
     <PackageVersion Include="NuGet.ProjectModel" Version="6.8.0-rc.112" />
     <PackageVersion Include="Microsoft.TestPlatform.TranslationLayer" Version="$(MicrosoftTestPlatformVersion)" />
     <PackageVersion Include="Microsoft.TestPlatform.ObjectModel" Version="$(MicrosoftTestPlatformVersion)" />
-    <PackageVersion Include="Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace" Version="7.0.0-preview.23525.7" />
+    <PackageVersion Include="Microsoft.AspNetCore.Razor.ExternalAccess.RoslynWorkspace" Version="7.0.0-preview.24165.3" />
 
     <!--
       Analyzers

From 134bc2e6f0edbe13c7cc465d97592d75f9d1a197 Mon Sep 17 00:00:00 2001
From: Rikki Gibson <rigibson@microsoft.com>
Date: Mon, 18 Mar 2024 19:24:03 -0700
Subject: [PATCH 110/170] Implement GetInterceptorMethod public API (#72279)

---
 .../Portable/BoundTree/BoundExpression.cs     |  12 +-
 .../CSharp/Portable/CSharpExtensions.cs       |   8 +
 .../CSharp/Portable/CSharpParseOptions.cs     |  46 +-
 .../Portable/Compilation/CSharpCompilation.cs |  23 +-
 .../Compilation/CSharpSemanticModel.cs        |  16 +
 .../CSharp/Portable/PublicAPI.Unshipped.txt   |   1 +
 .../Source/SourceMemberContainerSymbol.cs     |  22 +
 .../Symbols/Source/SourceModuleSymbol.cs      |  80 ++-
 .../Symbols/Source/SourceNamespaceSymbol.cs   |   6 +-
 .../Portable/Syntax/SyntaxNodeExtensions.cs   |  15 +
 .../Semantic/Semantics/InterceptorsTests.cs   | 624 ++++++++++++++++++
 .../InternalUtilities/RoslynExperiments.cs    |   3 +
 .../Core/Portable/MemoryExtensions.cs         |  13 +
 13 files changed, 835 insertions(+), 34 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs
index 22ebc3c0afd68..5100cea5bcaa9 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundExpression.cs
@@ -27,17 +27,7 @@ public SimpleNameSyntax? InterceptableNameSyntax
                     return null;
                 }
 
-                // If a qualified name is used as a valid receiver of an invocation syntax at some point,
-                // we probably want to treat it similarly to a MemberAccessExpression.
-                // However, we don't expect to encounter it.
-                Debug.Assert(syntax.Expression is not QualifiedNameSyntax);
-
-                return syntax.Expression switch
-                {
-                    MemberAccessExpressionSyntax memberAccess => memberAccess.Name,
-                    SimpleNameSyntax name => name,
-                    _ => null
-                };
+                return syntax.GetInterceptableNameSyntax();
             }
         }
 
diff --git a/src/Compilers/CSharp/Portable/CSharpExtensions.cs b/src/Compilers/CSharp/Portable/CSharpExtensions.cs
index dc954a88f0886..c42af7489034b 100644
--- a/src/Compilers/CSharp/Portable/CSharpExtensions.cs
+++ b/src/Compilers/CSharp/Portable/CSharpExtensions.cs
@@ -1630,6 +1630,14 @@ public static Conversion ClassifyConversion(this SemanticModel? semanticModel, i
             var csmodel = semanticModel as CSharpSemanticModel;
             return csmodel?.GetDeclaredSymbol(node, cancellationToken);
         }
+
+        /// <summary>If the call represented by <paramref name="node"/> is referenced in an InterceptsLocationAttribute, returns the original definition symbol which is decorated with that attribute. Otherwise, returns null.</summary>
+        [Experimental(RoslynExperiments.Interceptors, UrlFormat = RoslynExperiments.Interceptors_Url)]
+        public static IMethodSymbol? GetInterceptorMethod(this SemanticModel? semanticModel, InvocationExpressionSyntax node, CancellationToken cancellationToken = default)
+        {
+            var csModel = semanticModel as CSharpSemanticModel;
+            return csModel?.GetInterceptorMethod(node, cancellationToken);
+        }
         #endregion
     }
 }
diff --git a/src/Compilers/CSharp/Portable/CSharpParseOptions.cs b/src/Compilers/CSharp/Portable/CSharpParseOptions.cs
index 30923b47de6f2..675f7cd9db8ed 100644
--- a/src/Compilers/CSharp/Portable/CSharpParseOptions.cs
+++ b/src/Compilers/CSharp/Portable/CSharpParseOptions.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -186,19 +187,46 @@ internal ImmutableArray<ImmutableArray<string>> InterceptorsPreviewNamespaces
                 }
 
                 // e.g. [["System", "Threading"], ["System", "Collections"]]
-                ImmutableArray<ImmutableArray<string>> previewNamespaces;
-                if (Features.TryGetValue("InterceptorsPreviewNamespaces", out var namespaces))
+                ImmutableArray<ImmutableArray<string>> previewNamespaces = Features.TryGetValue("InterceptorsPreviewNamespaces", out var namespaces) && namespaces.Length > 0
+                    ? makeNamespaces(namespaces)
+                    : ImmutableArray<ImmutableArray<string>>.Empty;
+
+                ImmutableInterlocked.InterlockedInitialize(ref _interceptorsPreviewNamespaces, previewNamespaces);
+                return previewNamespaces;
+
+                static ImmutableArray<ImmutableArray<string>> makeNamespaces(string namespaces)
                 {
-                    previewNamespaces = namespaces
-                        .Split(';')
-                        .SelectAsArray(segment => segment.Split('.').ToImmutableArray());
+                    var builder = ArrayBuilder<ImmutableArray<string>>.GetInstance();
+                    var singleNamespaceBuilder = ArrayBuilder<string>.GetInstance();
+                    int currentIndex = 0;
+                    while (currentIndex < namespaces.Length && namespaces.IndexOf(';', currentIndex) is not -1 and var semicolonIndex)
+                    {
+                        addSingleNamespaceParts(builder, singleNamespaceBuilder, namespaces.AsSpan(currentIndex, semicolonIndex - currentIndex));
+                        currentIndex = semicolonIndex + 1;
+                    }
+
+                    addSingleNamespaceParts(builder, singleNamespaceBuilder, namespaces.AsSpan(currentIndex));
+                    singleNamespaceBuilder.Free();
+                    return builder.ToImmutableAndFree();
                 }
-                else
+
+                static void addSingleNamespaceParts(ArrayBuilder<ImmutableArray<string>> namespacesBuilder, ArrayBuilder<string> singleNamespaceBuilder, ReadOnlySpan<char> @namespace)
                 {
-                    previewNamespaces = ImmutableArray<ImmutableArray<string>>.Empty;
+                    int currentIndex = 0;
+                    while (currentIndex < @namespace.Length && @namespace.IndexOf('.', currentIndex) is not -1 and var dotIndex)
+                    {
+                        singleNamespaceBuilder.Add(@namespace.Slice(currentIndex, dotIndex - currentIndex).ToString());
+                        currentIndex = dotIndex + 1;
+                    }
+                    singleNamespaceBuilder.Add(@namespace.Slice(currentIndex).ToString());
+
+                    if (!namespacesBuilder.Any(ns => ns.SequenceEqual(singleNamespaceBuilder)))
+                    {
+                        namespacesBuilder.Add(singleNamespaceBuilder.ToImmutable());
+                    }
+
+                    singleNamespaceBuilder.Clear();
                 }
-                ImmutableInterlocked.InterlockedInitialize(ref _interceptorsPreviewNamespaces, previewNamespaces);
-                return previewNamespaces;
             }
         }
 
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index 18c0cf52a71d2..16a451b1d9bf5 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -2396,12 +2396,15 @@ internal void AddModuleInitializerMethod(MethodSymbol method)
             LazyInitializer.EnsureInitialized(ref _moduleInitializerMethods).Add(method);
         }
 
+        internal bool InterceptorsDiscoveryComplete;
+
         // NB: the 'Many' case for these dictionary values means there are duplicates. An error is reported for this after binding.
         private ConcurrentDictionary<(string FilePath, int Line, int Character), OneOrMany<(Location AttributeLocation, MethodSymbol Interceptor)>>? _interceptions;
 
         internal void AddInterception(string filePath, int line, int character, Location attributeLocation, MethodSymbol interceptor)
         {
             Debug.Assert(!_declarationDiagnosticsFrozen);
+            Debug.Assert(!InterceptorsDiscoveryComplete);
 
             var dictionary = LazyInitializer.EnsureInitialized(ref _interceptions);
             dictionary.AddOrUpdate((filePath, line, character),
@@ -2426,25 +2429,23 @@ internal void AddInterception(string filePath, int line, int character, Location
 
         internal (Location AttributeLocation, MethodSymbol Interceptor)? TryGetInterceptor(Location? callLocation)
         {
-            if (_interceptions is null || callLocation is null)
+            if (callLocation is null || !callLocation.IsInSource)
+            {
+                return null;
+            }
+
+            ((SourceModuleSymbol)SourceModule).DiscoverInterceptorsIfNeeded();
+            if (_interceptions is null)
             {
                 return null;
             }
 
             var callLineColumn = callLocation.GetLineSpan().Span.Start;
-            Debug.Assert(callLocation.SourceTree is not null);
             var key = (callLocation.SourceTree.FilePath, callLineColumn.Line, callLineColumn.Character);
 
-            if (_interceptions.TryGetValue(key, out var interceptionsAtAGivenLocation))
+            if (_interceptions.TryGetValue(key, out var interceptionsAtAGivenLocation) && interceptionsAtAGivenLocation is [var oneInterception])
             {
-                if (interceptionsAtAGivenLocation is [var oneInterception])
-                {
-                    return oneInterception;
-                }
-
-                // Duplicate interceptors is an error in the declaration phase.
-                // This method is only expected to be called if no such errors are present.
-                throw ExceptionUtilities.Unreachable();
+                return oneInterception;
             }
 
             return null;
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs
index 638b978c601bc..df844fd007afa 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs
@@ -5200,6 +5200,22 @@ protected sealed override ISymbol GetDeclaredSymbolCore(SyntaxNode node, Cancell
                 : ImmutableArray<ISymbol>.Empty;
         }
 
+#nullable enable
+        public IMethodSymbol? GetInterceptorMethod(InvocationExpressionSyntax node, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            CheckSyntaxNode(node);
+
+            if (node.GetInterceptableNameSyntax() is { } nameSyntax && Compilation.TryGetInterceptor(nameSyntax.GetLocation()) is (_, MethodSymbol interceptor))
+            {
+                return interceptor.GetPublicSymbol();
+            }
+
+            return null;
+        }
+#nullable disable
+
         protected static SynthesizedPrimaryConstructor TryGetSynthesizedPrimaryConstructor(TypeDeclarationSyntax node, NamedTypeSymbol type)
         {
             if (type is SourceMemberContainerTypeSymbol { PrimaryConstructor: { } primaryConstructor }
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
index aa9ee9c93b4e4..d3bb932bfcec2 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
@@ -7,3 +7,4 @@ static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Mic
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetElementConversion(this Microsoft.CodeAnalysis.Operations.ISpreadOperation! spread) -> Microsoft.CodeAnalysis.CSharp.Conversion
 static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.CrefParameter(Microsoft.CodeAnalysis.SyntaxToken refKindKeyword, Microsoft.CodeAnalysis.SyntaxToken readOnlyKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax! type) -> Microsoft.CodeAnalysis.CSharp.Syntax.CrefParameterSyntax!
 [RSEXPERIMENTAL001]Microsoft.CodeAnalysis.CSharp.CSharpCompilation.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree! syntaxTree, Microsoft.CodeAnalysis.SemanticModelOptions options) -> Microsoft.CodeAnalysis.SemanticModel!
+[RSEXPERIMENTAL002]static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetInterceptorMethod(this Microsoft.CodeAnalysis.SemanticModel? semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.InvocationExpressionSyntax! node, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.IMethodSymbol?
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
index d6de576a1d2c8..dce4856200ae3 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs
@@ -5245,6 +5245,28 @@ public override bool MightContainExtensionMethods
 
         #endregion
 
+        internal void DiscoverInterceptors(ArrayBuilder<NamespaceOrTypeSymbol> toSearch)
+        {
+            foreach (var type in this.GetTypeMembers())
+            {
+                toSearch.Add(type);
+            }
+
+            if (!declaration.AnyMemberHasAttributes)
+            {
+                return;
+            }
+
+            foreach (var member in this.GetMembersUnordered())
+            {
+                if (member is MethodSymbol { MethodKind: MethodKind.Ordinary })
+                {
+                    // force binding attributes and populating compilation-level structures
+                    member.GetAttributes();
+                }
+            }
+        }
+
         public sealed override NamedTypeSymbol ConstructedFrom
         {
             get { return this; }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceModuleSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceModuleSymbol.cs
index 2ece0db1dbe05..229f61355c2dd 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceModuleSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceModuleSymbol.cs
@@ -273,6 +273,9 @@ internal override void ForceComplete(SourceLocation? locationOpt, Predicate<Symb
 
                         if (this.GlobalNamespace.HasComplete(CompletionPart.MembersCompleted))
                         {
+                            // Completing the global namespace members means all InterceptsLocationAttributes have been bound.
+                            Volatile.Write(ref DeclaringCompilation.InterceptorsDiscoveryComplete, true);
+
                             _state.NotePartComplete(CompletionPart.MembersCompleted);
                         }
                         else
@@ -295,7 +298,6 @@ internal override void ForceComplete(SourceLocation? locationOpt, Predicate<Symb
                 _state.SpinWaitComplete(incompletePart, cancellationToken);
             }
         }
-#nullable disable
 
         private void ValidateLinkedAssemblies(BindingDiagnosticBag diagnostics, CancellationToken cancellationToken)
         {
@@ -322,6 +324,82 @@ private void ValidateLinkedAssemblies(BindingDiagnosticBag diagnostics, Cancella
             }
         }
 
+        internal void DiscoverInterceptorsIfNeeded()
+        {
+            if (!Volatile.Read(ref DeclaringCompilation.InterceptorsDiscoveryComplete))
+            {
+                discoverInterceptors();
+                Volatile.Write(ref DeclaringCompilation.InterceptorsDiscoveryComplete, true);
+            }
+
+            void discoverInterceptors()
+            {
+                var location = this.GlobalNamespace.GetFirstLocationOrNone();
+                if (!location.IsInSource)
+                {
+                    return;
+                }
+
+                var toVisit = ArrayBuilder<NamespaceOrTypeSymbol>.GetInstance();
+
+                // Search the namespaces which were indicated to contain interceptors.
+                ImmutableArray<ImmutableArray<string>> interceptorsNamespaces = ((CSharpParseOptions)location.SourceTree.Options).InterceptorsPreviewNamespaces;
+                foreach (ImmutableArray<string> namespaceParts in interceptorsNamespaces)
+                {
+                    if (namespaceParts is ["global"])
+                    {
+                        toVisit.Clear();
+                        toVisit.Add(GlobalNamespace);
+                        // No point in continuing, we already are going to search the entire module in this case.
+                        break;
+                    }
+
+                    var cursor = GlobalNamespace;
+                    foreach (string namespacePart in namespaceParts)
+                    {
+                        cursor = (NamespaceSymbol?)cursor.GetNestedNamespace(namespacePart);
+                        if (cursor is null)
+                        {
+                            break;
+                        }
+                    }
+
+                    if (cursor is not null)
+                    {
+                        toVisit.Add(cursor);
+                    }
+                }
+
+                while (toVisit.Count > 0)
+                {
+                    var item = toVisit.Pop();
+                    if (item is SourceMemberContainerTypeSymbol type)
+                    {
+                        type.DiscoverInterceptors(toVisit);
+                    }
+                    else if (item is SourceNamespaceSymbol @namespace)
+                    {
+                        foreach (var member in @namespace.GetMembers())
+                        {
+                            if (member is not NamespaceOrTypeSymbol namespaceOrType)
+                            {
+                                throw ExceptionUtilities.UnexpectedValue(member);
+                            }
+
+                            toVisit.Add(namespaceOrType);
+                        }
+                    }
+                    else
+                    {
+                        throw ExceptionUtilities.UnexpectedValue(item);
+                    }
+                }
+
+                toVisit.Free();
+            }
+        }
+#nullable disable
+
         public override ImmutableArray<Location> Locations
         {
             get
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
index 3463ef861e252..a02eb45cc149c 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamespaceSymbol.cs
@@ -100,8 +100,10 @@ public override ImmutableArray<Location> Locations
             }
         }
 
-        public override Location TryGetFirstLocation()
-            => _mergedDeclaration.Declarations[0].NameLocation;
+#nullable enable
+        public override Location? TryGetFirstLocation()
+            => _mergedDeclaration.Declarations is [var declaration, ..] ? declaration.NameLocation : null;
+#nullable disable
 
         public override bool HasLocationContainedWithin(SyntaxTree tree, TextSpan declarationSpan, out bool wasZeroWidthMatch)
         {
diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxNodeExtensions.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxNodeExtensions.cs
index f315f0a24792a..7d65e42cb3279 100644
--- a/src/Compilers/CSharp/Portable/Syntax/SyntaxNodeExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxNodeExtensions.cs
@@ -361,5 +361,20 @@ private static bool IsDeconstructionCompatibleArgument(ExpressionSyntax expressi
 
             return false;
         }
+
+        internal static SimpleNameSyntax? GetInterceptableNameSyntax(this InvocationExpressionSyntax invocation)
+        {
+            // If a qualified name is used as a valid receiver of an invocation syntax at some point,
+            // we probably want to treat it similarly to a MemberAccessExpression.
+            // However, we don't expect to encounter it.
+            Debug.Assert(invocation.Expression is not QualifiedNameSyntax);
+
+            return invocation.Expression switch
+            {
+                MemberAccessExpressionSyntax memberAccess => memberAccess.Name,
+                SimpleNameSyntax name => name,
+                _ => null
+            };
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/InterceptorsTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/InterceptorsTests.cs
index 6b013851422dc..b1cf3f2f8a850 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/InterceptorsTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/InterceptorsTests.cs
@@ -2,11 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#pragma warning disable RSEXPERIMENTAL002 // Tests for experimental API
+
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -152,6 +155,7 @@ class D
         sadCase("true");
         sadCase(" NS1");
         sadCase(";");
+        sadCase(";;");
         sadCase("");
         sadCase("NS1 ;");
         sadCase("NS1..NS2;");
@@ -164,6 +168,7 @@ class D
         happyCase(";NS1");
         happyCase("NS1.NS2");
         happyCase("NS2;NS1.NS2");
+        happyCase("NS2;;NS1.NS2");
 
         void sadCase(string featureValue)
         {
@@ -5798,4 +5803,623 @@ static class D
             //     [InterceptsLocation("Program.cs", 15, 11)]
             Diagnostic(ErrorCode.ERR_RefConstraintNotSatisfied, @"InterceptsLocation(""Program.cs"", 15, 11)").WithArguments("D.Generic<T, U>(C<T>, U)", "T", "int").WithLocation(6, 6));
     }
+
+    [Theory]
+    [CombinatorialData]
+    public void GetInterceptorMethod_01(bool checkBeforeDiagnostics)
+    {
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            static class D
+            {
+                [InterceptsLocation("Program.cs", 1, 3)]
+                public static void Interceptor() => Console.Write(1);
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: RegularWithInterceptors);
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        if (checkBeforeDiagnostics)
+        {
+            check();
+        }
+
+        comp.VerifyEmitDiagnostics();
+
+        if (!checkBeforeDiagnostics)
+        {
+            check();
+        }
+
+        void check()
+        {
+            var interceptor = model.GetInterceptorMethod(call);
+            Assert.Equal("void D.Interceptor()", interceptor.ToTestDisplayString());
+        }
+    }
+
+    [Theory]
+    [CombinatorialData]
+    public void GetInterceptorMethod_02(bool checkBeforeDiagnostics)
+    {
+        var source = ("""
+            C.M(42);
+
+            class C
+            {
+                public static void M<T>(T t) => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            static class D
+            {
+                [InterceptsLocation("Program.cs", 1, 3)]
+                public static void Interceptor<T>(T t) => Console.Write(t);
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: RegularWithInterceptors);
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        if (checkBeforeDiagnostics)
+        {
+            check();
+        }
+
+        comp.VerifyEmitDiagnostics();
+
+        if (!checkBeforeDiagnostics)
+        {
+            check();
+        }
+
+        void check()
+        {
+            var interceptor = model.GetInterceptorMethod(call);
+            Assert.Equal("void D.Interceptor<T>(T t)", interceptor.ToTestDisplayString());
+            Assert.True(interceptor!.IsDefinition);
+        }
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_03()
+    {
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                static class D
+                {
+                    [InterceptsLocation("Program.cs", 1, 3)]
+                    public static void Interceptor() => Console.Write(1);
+                }
+            }
+
+            class E : Attribute
+            {
+                [E]
+                public void M()
+                {
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.D.Interceptor()", interceptor.ToTestDisplayString());
+        Assert.True(interceptor.GetSymbol()!.HasComplete(CompletionPart.Attributes));
+
+        // Do not bind attributes on methods in irrelevant namespaces when discovering interceptors
+        var EM = comp.GetMember<MethodSymbol>("E.M");
+        Assert.False(EM.HasComplete(CompletionPart.Attributes));
+
+        comp.VerifyEmitDiagnostics();
+
+        Assert.True(EM.HasComplete(CompletionPart.Attributes));
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_04()
+    {
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace NotInterceptors
+            {
+                static class D
+                {
+                    [InterceptsLocation("Program.cs", 1, 3)]
+                    public static void Interceptor() => Console.Write(1);
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        // Interceptor declaration is erroneous (not within expected namespace), we don't care about failing to discover it.
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Null(interceptor);
+
+        comp.VerifyEmitDiagnostics(
+            // Interceptor.cs(8,10): error CS9137: The 'interceptors' experimental feature is not enabled in this namespace. Add '<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);NotInterceptors</InterceptorsPreviewNamespaces>' to your project.
+            //         [InterceptsLocation("Program.cs", 1, 3)]
+            Diagnostic(ErrorCode.ERR_InterceptorsFeatureNotEnabled, @"InterceptsLocation(""Program.cs"", 1, 3)").WithArguments("<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);NotInterceptors</InterceptorsPreviewNamespaces>").WithLocation(8, 10));
+
+        interceptor = model.GetInterceptorMethod(call);
+        Assert.Null(interceptor);
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_05()
+    {
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                class D
+                {
+                    [InterceptsLocation("Program.cs", 1, 3)]
+                    public static void Interceptor() => Console.Write(1);
+                }
+
+                class E : Attribute
+                {
+                    [E]
+                    public void M()
+                    {
+                    }
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.D.Interceptor()", interceptor.ToTestDisplayString());
+        Assert.True(interceptor.GetSymbol()!.HasComplete(CompletionPart.Attributes));
+
+        // Possibly irrelevant attributes within interceptors namespaces are still bound when discovering interceptors.
+        // https://github.com/dotnet/roslyn/issues/72410: perhaps QuickAttributes should be used in order to bail out in some cases.
+        var EM = comp.GetMember<MethodSymbol>("Interceptors.E.M");
+        Assert.True(EM.HasComplete(CompletionPart.Attributes));
+
+        comp.VerifyEmitDiagnostics();
+
+        Assert.True(EM.HasComplete(CompletionPart.Attributes));
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_06()
+    {
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                static class D
+                {
+                    [InterceptsLocation("Program.cs", 1, 3)]
+                    public static void Interceptor1(int i) => Console.Write(i);
+
+                    [InterceptsLocation("Program.cs", 1, 3)]
+                    public static void Interceptor2() => Console.Write(2);
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Null(interceptor);
+
+        comp.VerifyEmitDiagnostics(
+            // Interceptor.cs(8,10): error CS9153: The indicated call is intercepted multiple times.
+            //         [InterceptsLocation("Program.cs", 1, 3)]
+            Diagnostic(ErrorCode.ERR_DuplicateInterceptor, @"InterceptsLocation(""Program.cs"", 1, 3)").WithLocation(8, 10),
+            // Interceptor.cs(11,10): error CS9153: The indicated call is intercepted multiple times.
+            //         [InterceptsLocation("Program.cs", 1, 3)]
+            Diagnostic(ErrorCode.ERR_DuplicateInterceptor, @"InterceptsLocation(""Program.cs"", 1, 3)").WithLocation(11, 10));
+
+        interceptor = model.GetInterceptorMethod(call);
+        Assert.Null(interceptor);
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_07()
+    {
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                static class D
+                {
+                    [InterceptsLocation("Program.cs", 1, 3)]
+                    public static void Interceptor1() => Console.Write(1);
+                }
+            }
+            
+            namespace NotInterceptors
+            {
+                static class D
+                {
+                    [InterceptsLocation("Program.cs", 1, 3)]
+                    public static void Interceptor2() => Console.Write(2);
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.D.Interceptor1()", interceptor.ToTestDisplayString());
+
+        comp.VerifyEmitDiagnostics(
+            // Interceptor.cs(17,10): error CS9137: The 'interceptors' experimental feature is not enabled in this namespace. Add '<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);NotInterceptors</InterceptorsPreviewNamespaces>' to your project.
+            //         [InterceptsLocation("Program.cs", 1, 3)]
+            Diagnostic(ErrorCode.ERR_InterceptorsFeatureNotEnabled, @"InterceptsLocation(""Program.cs"", 1, 3)").WithArguments("<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);NotInterceptors</InterceptorsPreviewNamespaces>").WithLocation(17, 10));
+
+        interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.D.Interceptor1()", interceptor.ToTestDisplayString());
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_08()
+    {
+        // Demonstrate that nested types are searched for InterceptsLocationAttributes
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                static class Outer
+                {
+                    public static class D
+                    {
+                        [InterceptsLocation("Program.cs", 1, 3)]
+                        public static void Interceptor1() => Console.Write(1);
+                    }
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.Outer.D.Interceptor1()", interceptor.ToTestDisplayString());
+
+        comp.VerifyEmitDiagnostics();
+
+        interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.Outer.D.Interceptor1()", interceptor.ToTestDisplayString());
+    }
+
+    [Theory]
+    [CombinatorialData]
+    public void GetInterceptorMethod_09(bool featureExists)
+    {
+        // InterceptorsPreviewNamespaces is empty or does not exist
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                static class Outer
+                {
+                    public static class D
+                    {
+                        [InterceptsLocation("Program.cs", 1, 3)]
+                        public static void Interceptor1() => Console.Write(1);
+                    }
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: featureExists ? TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "") : TestOptions.Regular);
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        Assert.Null(model.GetInterceptorMethod(call));
+        comp.VerifyEmitDiagnostics(
+            // Interceptor.cs(10,14): error CS9137: The 'interceptors' experimental feature is not enabled in this namespace. Add '<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);Interceptors</InterceptorsPreviewNamespaces>' to your project.
+            //             [InterceptsLocation("Program.cs", 1, 3)]
+            Diagnostic(ErrorCode.ERR_InterceptorsFeatureNotEnabled, @"InterceptsLocation(""Program.cs"", 1, 3)").WithArguments("<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);Interceptors</InterceptorsPreviewNamespaces>").WithLocation(10, 14));
+        Assert.Null(model.GetInterceptorMethod(call));
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_10()
+    {
+        // InterceptorsPreviewNamespaces has duplicates
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                static class Outer
+                {
+                    public static class D
+                    {
+                        [InterceptsLocation("Program.cs", 1, 3)]
+                        public static void Interceptor1() => Console.Write(1);
+                    }
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors;Interceptors"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.Outer.D.Interceptor1()", interceptor.ToTestDisplayString());
+
+        comp.VerifyEmitDiagnostics();
+
+        interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.Outer.D.Interceptor1()", interceptor.ToTestDisplayString());
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_11()
+    {
+        // Compilation does not contain any interceptors
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var comp = CreateCompilation(new[] { source, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Null(interceptor);
+
+        comp.VerifyEmitDiagnostics();
+
+        interceptor = model.GetInterceptorMethod(call);
+        Assert.Null(interceptor);
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_12()
+    {
+        // Compilation contains no files
+        var comp = CreateCompilation([], parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors"));
+
+        // We can't use GetInterceptorMethod without a SemanticModel and we can't get a SemanticModel when the compilation contains no trees.
+        // But, we can exercise some internal API for theoretical edge cases to see if it is robust (does not throw, updates expected flags).
+        ((SourceModuleSymbol)comp.SourceModule).DiscoverInterceptorsIfNeeded();
+        Assert.True(comp.InterceptorsDiscoveryComplete);
+    }
+
+    [Theory]
+    [InlineData("Interceptors")]
+    [InlineData("Interceptors.Nested")]
+    public void GetInterceptorMethod_13(string @namespace)
+    {
+        // Demonstrate that nested namespaces are searched for InterceptsLocationAttributes
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                namespace Nested
+                {
+                    public static class D
+                    {
+                        [InterceptsLocation("Program.cs", 1, 3)]
+                        public static void Interceptor1() => Console.Write(1);
+                    }
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", @namespace));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        var interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.Nested.D.Interceptor1()", interceptor.ToTestDisplayString());
+
+        comp.VerifyEmitDiagnostics();
+
+        interceptor = model.GetInterceptorMethod(call);
+        Assert.Equal("void Interceptors.Nested.D.Interceptor1()", interceptor.ToTestDisplayString());
+    }
+
+    [Fact]
+    public void GetInterceptorMethod_14()
+    {
+        // Interceptor is in a parent of the expected namespace. Not discovered.
+        var source = ("""
+            C.M();
+
+            class C
+            {
+                public static void M() => throw null;
+            }
+            """, "Program.cs");
+
+        var interceptorSource = ("""
+            using System;
+            using System.Runtime.CompilerServices;
+
+            namespace Interceptors
+            {
+                public static class D
+                {
+                    [InterceptsLocation("Program.cs", 1, 3)]
+                    public static void Interceptor1() => Console.Write(1);
+                }
+            }
+            """, "Interceptor.cs");
+
+        var comp = CreateCompilation(new[] { source, interceptorSource, s_attributesSource }, parseOptions: TestOptions.Regular.WithFeature("InterceptorsPreviewNamespaces", "Interceptors.Nested"));
+
+        var tree = comp.SyntaxTrees[0];
+        var model = comp.GetSemanticModel(tree);
+        var call = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single();
+
+        Assert.Null(model.GetInterceptorMethod(call));
+
+        comp.VerifyEmitDiagnostics(
+            // Interceptor.cs(8,10): error CS9137: The 'interceptors' experimental feature is not enabled in this namespace. Add '<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);Interceptors</InterceptorsPreviewNamespaces>' to your project.
+            //         [InterceptsLocation("Program.cs", 1, 3)]
+            Diagnostic(ErrorCode.ERR_InterceptorsFeatureNotEnabled, @"InterceptsLocation(""Program.cs"", 1, 3)").WithArguments("<InterceptorsPreviewNamespaces>$(InterceptorsPreviewNamespaces);Interceptors</InterceptorsPreviewNamespaces>").WithLocation(8, 10));
+
+        Assert.Null(model.GetInterceptorMethod(call));
+    }
 }
diff --git a/src/Compilers/Core/Portable/InternalUtilities/RoslynExperiments.cs b/src/Compilers/Core/Portable/InternalUtilities/RoslynExperiments.cs
index b6b4b37d4490d..75e810ab03512 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/RoslynExperiments.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/RoslynExperiments.cs
@@ -11,4 +11,7 @@ internal static class RoslynExperiments
 {
     internal const string NullableDisabledSemanticModel = "RSEXPERIMENTAL001";
     internal const string NullableDisabledSemanticModel_Url = "https://github.com/dotnet/roslyn/issues/70609";
+
+    internal const string Interceptors = "RSEXPERIMENTAL002";
+    internal const string Interceptors_Url = "https://github.com/dotnet/csharplang/issues/7009";
 }
diff --git a/src/Compilers/Core/Portable/MemoryExtensions.cs b/src/Compilers/Core/Portable/MemoryExtensions.cs
index b17a41d2dca7a..f51f60ca3b9df 100644
--- a/src/Compilers/Core/Portable/MemoryExtensions.cs
+++ b/src/Compilers/Core/Portable/MemoryExtensions.cs
@@ -10,6 +10,19 @@ namespace Microsoft.CodeAnalysis
 {
     internal static class MemoryExtensions
     {
+        public static int IndexOf(this ReadOnlySpan<char> span, char target, int startIndex)
+        {
+            for (int i = startIndex; i < span.Length; i++)
+            {
+                if (span[i] == target)
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
         public static int IndexOfAny(this ReadOnlySpan<char> span, char[] characters)
         {
             for (int i = 0; i < span.Length; i++)

From c2c4be03ec196db27f9eb84a75c6023d852c3a7e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 18 Mar 2024 20:01:28 -0700
Subject: [PATCH 111/170] Fix

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

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
index a974cb7858f08..f16303c0c6256 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
@@ -146,7 +146,7 @@ public EventHookupSession(
 
         public (Task<string?> eventNameTask, CancellationTokenSource cancellationTokenSource) DetachEventNameTask()
         {
-            _threadingContext.ThrowIfNotOnBackgroundThread();
+            _threadingContext.ThrowIfNotOnUIThread();
 
             Contract.ThrowIfNull(_eventNameTask);
             Contract.ThrowIfNull(_cancellationTokenSource);

From 0383ef44c2d49da8eb8b20cf0aba835a08f9a987 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 18 Mar 2024 20:04:18 -0700
Subject: [PATCH 112/170] Add check

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

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
index f16303c0c6256..344e5cadfd71e 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
@@ -132,7 +132,8 @@ public EventHookupSession(
                 {
                     await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(alwaysYield: true, cancellationToken);
 
-                    if (t.Result != null)
+                    // Once we compute the name, update the tooltip (if we haven't already been dismissed)
+                    if (this._eventNameTask != null && t.Result != null)
                     {
                         commandHandler.EventHookupSessionManager.EventHookupFoundInSession(this, t.Result);
                     }

From cd71e7f49257898a5229576897424557fe0ddb20 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrusn@microsoft.com>
Date: Mon, 18 Mar 2024 20:06:19 -0700
Subject: [PATCH 113/170] Fix

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

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index f6947aefe7546..ed1357c898a35 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -138,7 +138,7 @@ private async Task ExecuteCommandAsync(
                 // then attempt to send the tab through to the editor.  If other changes went through, don't send the
                 // tab through as it's likely to make things worse.
                 if (applicableToSpan.Snapshot.Version == subjectBuffer.CurrentSnapshot.Version &&
-                    textView.GetCaretPoint(subjectBuffer) != initialCaretPoint)
+                    textView.GetCaretPoint(subjectBuffer) == initialCaretPoint)
                 {
                     nextHandler();
                 }

From 9c73cd23ca21c173cf523c0a6a7699be2f945f0c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Tue, 19 Mar 2024 00:27:37 -0700
Subject: [PATCH 114/170] better thread transitions

---
 ...EventHookupCommandHandler_TabKeyCommand.cs | 20 +++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
index ed1357c898a35..b0a57873eaf63 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs
@@ -64,6 +64,7 @@ public void ExecuteCommand(TabKeyCommandArgs args, Action nextHandler, CommandEx
     private bool TryExecuteCommand(TabKeyCommandArgs args, Action nextHandler)
     {
         _threadingContext.ThrowIfNotOnUIThread();
+
         if (!_globalOptions.GetOption(EventHookupOptionsStorage.EventHookup))
             return false;
 
@@ -125,6 +126,8 @@ private async Task ExecuteCommandAsync(
         CancellationTokenSource eventNameCancellationTokenSource,
         SnapshotPoint initialCaretPoint)
     {
+        _threadingContext.ThrowIfNotOnUIThread();
+
         var textView = args.TextView;
         var subjectBuffer = args.SubjectBuffer;
 
@@ -134,6 +137,8 @@ private async Task ExecuteCommandAsync(
         {
             if (!await TryExecuteCommandAsync().ConfigureAwait(true))
             {
+                _threadingContext.ThrowIfNotOnUIThread();
+
                 // We didn't successfully handle the command.  If no other changes have gotten through in the mean time,
                 // then attempt to send the tab through to the editor.  If other changes went through, don't send the
                 // tab through as it's likely to make things worse.
@@ -171,17 +176,12 @@ async Task<bool> TryExecuteCommandAsync()
 
             var cancellationToken = waitContext.UserCancellationToken;
 
-            var eventHandlerMethodName = await eventNameTask.WithCancellation(cancellationToken).ConfigureAwait(false);
-            if (eventHandlerMethodName is null)
-                return false;
-
             var solutionAndRenameSpan = await TryGetNewSolutionWithAddedMethodAsync(
-                document, eventHandlerMethodName, initialCaretPoint.Position, cancellationToken).ConfigureAwait(false);
+                document, eventNameTask, initialCaretPoint.Position, cancellationToken).ConfigureAwait(true);
             if (solutionAndRenameSpan is null)
                 return false;
 
-            // switch back to the UI thread to now apply the change.
-            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+            _threadingContext.ThrowIfNotOnUIThread();
 
             // If anything changed in the view between computation and application, bail out.
             if (applicableToSpan.Snapshot.Version != subjectBuffer.CurrentSnapshot.Version ||
@@ -210,8 +210,12 @@ async Task<bool> TryExecuteCommandAsync()
     }
 
     private async Task<(Solution solution, TextSpan renameSpan)?> TryGetNewSolutionWithAddedMethodAsync(
-        Document document, string eventHandlerMethodName, int position, CancellationToken cancellationToken)
+        Document document, Task<string?> eventNameTask, int position, CancellationToken cancellationToken)
     {
+        var eventHandlerMethodName = await eventNameTask.WithCancellation(cancellationToken).ConfigureAwait(false);
+        if (eventHandlerMethodName is null)
+            return null;
+
         // Mark the += token with an annotation so we can find it after formatting
         var documentWithNameAndAnnotationsAdded = await AddMethodNameAndAnnotationsToSolutionAsync(
             document, eventHandlerMethodName, position, cancellationToken).ConfigureAwait(false);

From 6777b43e0fc237d0a5a284a0838c7ff033fc5eb6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Tue, 19 Mar 2024 01:06:30 -0700
Subject: [PATCH 115/170] disable diagnostics when solution crawler option is
 disabled

---
 ...cIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs | 6 ++++++
 .../Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs   | 4 +++-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs b/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs
index 411b95df18d8d..d0775eb283419 100644
--- a/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs
+++ b/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs
@@ -23,13 +23,16 @@ namespace Microsoft.CodeAnalysis.Diagnostics
 {
     internal class InProcOrRemoteHostAnalyzerRunner
     {
+        private readonly bool _enabled;
         private readonly IAsynchronousOperationListener _asyncOperationListener;
         public DiagnosticAnalyzerInfoCache AnalyzerInfoCache { get; }
 
         public InProcOrRemoteHostAnalyzerRunner(
+            bool enabled,
             DiagnosticAnalyzerInfoCache analyzerInfoCache,
             IAsynchronousOperationListener? operationListener = null)
         {
+            _enabled = enabled;
             AnalyzerInfoCache = analyzerInfoCache;
             _asyncOperationListener = operationListener ?? AsynchronousOperationListenerProvider.NullListener;
         }
@@ -64,6 +67,9 @@ private async Task<DiagnosticAnalysisResultMap<DiagnosticAnalyzer, DiagnosticAna
             bool getTelemetryInfo,
             CancellationToken cancellationToken)
         {
+            if (!_enabled)
+                return DiagnosticAnalysisResultMap<DiagnosticAnalyzer, DiagnosticAnalysisResult>.Empty;
+
             var result = await AnalyzeCoreAsync().ConfigureAwait(false);
             Debug.Assert(getTelemetryInfo || result.TelemetryInfo.IsEmpty);
             return result;
diff --git a/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs b/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
index 3bfa3692191b2..4ee7e585fd01f 100644
--- a/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
+++ b/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs
@@ -62,7 +62,9 @@ public DiagnosticIncrementalAnalyzer(
             _stateManager = new StateManager(workspace, analyzerInfoCache);
             _stateManager.ProjectAnalyzerReferenceChanged += OnProjectAnalyzerReferenceChanged;
 
-            _diagnosticAnalyzerRunner = new InProcOrRemoteHostAnalyzerRunner(analyzerInfoCache, analyzerService.Listener);
+            var enabled = this.AnalyzerService.GlobalOptions.GetOption(SolutionCrawlerRegistrationService.EnableSolutionCrawler);
+            _diagnosticAnalyzerRunner = new InProcOrRemoteHostAnalyzerRunner(
+                enabled, analyzerInfoCache, analyzerService.Listener);
         }
 
         internal IGlobalOptionService GlobalOptions => AnalyzerService.GlobalOptions;

From b691056d6c6c2c066b472e7c23e35adb302568b0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Tue, 19 Mar 2024 01:09:32 -0700
Subject: [PATCH 116/170] disable diagnostics when solution crawler option is
 disabled

---
 .../Features/Diagnostics/DocumentAnalysisExecutor.cs        | 2 +-
 .../EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs      | 6 +++---
 ...cIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs | 5 ++++-
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/Features/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor.cs b/src/Features/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor.cs
index 73343a8f3c6dd..f785abc52551a 100644
--- a/src/Features/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor.cs
+++ b/src/Features/LanguageServer/Protocol/Features/Diagnostics/DocumentAnalysisExecutor.cs
@@ -200,7 +200,7 @@ private async Task<ImmutableArray<Diagnostic>> GetSourceGeneratorDiagnosticsAsyn
         {
             try
             {
-                return await InProcOrRemoteHostAnalyzerRunner.GetSourceGeneratorDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false);
+                return await _diagnosticAnalyzerRunner.GetSourceGeneratorDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false);
             }
             catch when (_onAnalysisException != null)
             {
diff --git a/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs b/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs
index bfeefaaa60fb1..a2fd206083a6a 100644
--- a/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs
+++ b/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.Executor.cs
@@ -449,7 +449,7 @@ private static bool TryReduceAnalyzersToRun(
             return true;
         }
 
-        private static async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> MergeProjectDiagnosticAnalyzerDiagnosticsAsync(
+        private async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult>> MergeProjectDiagnosticAnalyzerDiagnosticsAsync(
             Project project,
             ImmutableArray<DiagnosticAnalyzer> ideAnalyzers,
             Compilation? compilation,
@@ -509,7 +509,7 @@ private static async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnal
             }
         }
 
-        private static async Task<(ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult> results, ImmutableHashSet<Document>? failedDocuments)> UpdateWithDocumentLoadAndGeneratorFailuresAsync(
+        private async Task<(ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult> results, ImmutableHashSet<Document>? failedDocuments)> UpdateWithDocumentLoadAndGeneratorFailuresAsync(
             ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnalysisResult> results,
             Project project,
             VersionStamp version,
@@ -542,7 +542,7 @@ private static async Task<ImmutableDictionary<DiagnosticAnalyzer, DiagnosticAnal
                     others: [],
                     documentIds: null));
 
-            var generatorDiagnostics = await InProcOrRemoteHostAnalyzerRunner.GetSourceGeneratorDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false);
+            var generatorDiagnostics = await _diagnosticAnalyzerRunner.GetSourceGeneratorDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false);
             var diagnosticResultBuilder = new DiagnosticAnalysisResultBuilder(project, version);
             foreach (var generatorDiagnostic in generatorDiagnostics)
             {
diff --git a/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs b/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs
index d0775eb283419..17751bcd9e7d0 100644
--- a/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs
+++ b/src/Features/LanguageServer/Protocol/Features/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.InProcOrRemoteHostAnalyzerRunner.cs
@@ -90,8 +90,11 @@ async Task<DiagnosticAnalysisResultMap<DiagnosticAnalyzer, DiagnosticAnalysisRes
             }
         }
 
-        public static async Task<ImmutableArray<Diagnostic>> GetSourceGeneratorDiagnosticsAsync(Project project, CancellationToken cancellationToken)
+        public async Task<ImmutableArray<Diagnostic>> GetSourceGeneratorDiagnosticsAsync(Project project, CancellationToken cancellationToken)
         {
+            if (!_enabled)
+                return [];
+
             var options = project.Solution.Services.GetRequiredService<IWorkspaceConfigurationService>().Options;
             var remoteHostClient = await RemoteHostClient.TryGetClientAsync(project, cancellationToken).ConfigureAwait(false);
             if (remoteHostClient != null)

From 4880891bd00b15afccf5c17eee3512d440126589 Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Tue, 19 Mar 2024 07:07:22 -0700
Subject: [PATCH 117/170] Reduce allocations in AbstractTypeMap (#72588)

Partial fix for https://github.com/dotnet/roslyn/issues/68996

Both SubstituteTypesWithoutModifiers and SubstituteNamedTypes allocate a temporary array that is used to potentially return an immutable array. Previously, this immutable array was allocated if needed, whereas we can not perform the extra allocation by utilizing ImmutableCollectionsMarshal as the array being wrapped is local to this method.
---
 src/Compilers/CSharp/Portable/Symbols/AbstractTypeMap.cs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/AbstractTypeMap.cs b/src/Compilers/CSharp/Portable/Symbols/AbstractTypeMap.cs
index 555fcbf36d926..ee43c93bf9e79 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AbstractTypeMap.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/AbstractTypeMap.cs
@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -313,7 +314,7 @@ internal ImmutableArray<TypeSymbol> SubstituteTypesWithoutModifiers(ImmutableArr
                 }
             }
 
-            return result != null ? result.AsImmutableOrNull() : original;
+            return result != null ? ImmutableCollectionsMarshal.AsImmutableArray(result) : original;
         }
 
         internal ImmutableArray<TypeWithAnnotations> SubstituteTypes(ImmutableArray<TypeWithAnnotations> original)
@@ -430,7 +431,7 @@ internal ImmutableArray<NamedTypeSymbol> SubstituteNamedTypes(ImmutableArray<Nam
                 }
             }
 
-            return result != null ? result.AsImmutableOrNull() : original;
+            return result != null ? ImmutableCollectionsMarshal.AsImmutableArray(result) : original;
         }
     }
 }

From 02069cef3ee4f08b37a1b5f2371c26041c41a5bd Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Tue, 19 Mar 2024 07:15:33 -0700
Subject: [PATCH 118/170] Reduce File I/O under the AnalyzerAssemblyLoader
 folder (#72412)

Assemblies and their corresponding resource dlls are copied/deleted under this folder on solution open. When opening Rosly, I see about 700 dlls copied/deleted under this folder. Over 90% of these dlls are resource dlls, not something in use for my setup.

This change separates the code that ensures the assembly is shadow-copied properly from the code that ensures that it's supporting resource assemblies are shadow-copied properly. Resource assemblies as copied on assembly load demand.

With this change locally, I see over 90% reduction in the number of these file I/O operations.
---
 .../AnalyzerAssemblyLoaderTests.cs            |  52 +++++-
 .../AnalyzerAssemblyLoader.Core.cs            |  11 +-
 .../AnalyzerAssemblyLoader.Desktop.cs         |  26 ++-
 .../AnalyzerAssemblyLoader.cs                 | 160 +++++++++---------
 .../DefaultAnalyzerAssemblyLoader.cs          |  13 +-
 .../ShadowCopyAnalyzerAssemblyLoader.cs       |  95 ++++++-----
 .../Remote/SnapshotSerializationTests.cs      |   5 +-
 .../Host/RemoteAnalyzerAssemblyLoader.cs      |   9 +-
 8 files changed, 234 insertions(+), 137 deletions(-)

diff --git a/src/Compilers/Core/CodeAnalysisTest/AnalyzerAssemblyLoaderTests.cs b/src/Compilers/Core/CodeAnalysisTest/AnalyzerAssemblyLoaderTests.cs
index 1baae26943926..5c47171fb8a6f 100644
--- a/src/Compilers/Core/CodeAnalysisTest/AnalyzerAssemblyLoaderTests.cs
+++ b/src/Compilers/Core/CodeAnalysisTest/AnalyzerAssemblyLoaderTests.cs
@@ -5,23 +5,21 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Text;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
 using Xunit.Abstractions;
-using Xunit.Sdk;
 using Microsoft.CodeAnalysis.VisualBasic;
-using Microsoft.CodeAnalysis.VisualBasic.Syntax;
+
 #if NETCOREAPP
 using Roslyn.Test.Utilities.CoreClr;
 using System.Runtime.Loader;
@@ -367,11 +365,32 @@ string getExpectedLoadPath(string path)
 
                 if (path.EndsWith(".resources.dll", StringComparison.Ordinal))
                 {
-                    return loader.GetRealSatelliteLoadPath(path) ?? "";
+                    return getRealSatelliteLoadPath(path) ?? "";
                 }
                 return loader.GetRealAnalyzerLoadPath(path ?? "");
             }
 
+            // When PreparePathToLoad is overridden this returns the most recent
+            // real path for the given analyzer satellite assembly path
+            string? getRealSatelliteLoadPath(string originalSatelliteFullPath)
+            {
+                // This is a satellite assembly, need to find the mapped path of the real assembly, then 
+                // adjust that mapped path for the suffix of the satellite assembly
+                //
+                // Example of dll and it's corresponding satellite assembly
+                //
+                //  c:\some\path\en-GB\util.resources.dll
+                //  c:\some\path\util.dll
+                var assemblyFileName = Path.ChangeExtension(Path.GetFileNameWithoutExtension(originalSatelliteFullPath), ".dll");
+
+                var assemblyDir = Path.GetDirectoryName(originalSatelliteFullPath)!;
+                var cultureInfo = CultureInfo.GetCultureInfo(Path.GetFileName(assemblyDir));
+                assemblyDir = Path.GetDirectoryName(assemblyDir)!;
+
+                // Real assembly is located in the directory above this one
+                var assemblyPath = Path.Combine(assemblyDir, assemblyFileName);
+                return loader.GetRealSatelliteLoadPath(assemblyPath, cultureInfo);
+            }
         }
 
         private static void VerifyAssemblies(AnalyzerAssemblyLoader loader, IEnumerable<Assembly> assemblies, int? copyCount, params string[] assemblyPaths)
@@ -1347,8 +1366,31 @@ public void AssemblyLoading_Resources(AnalyzerTestKind kind)
                 // dlls don't apply for this count.
                 VerifyDependencyAssemblies(loader, copyCount: 1, analyzerPath, analyzerResourcesPath);
             });
+        }
 
+        [Theory]
+        [CombinatorialData]
+        public void AssemblyLoading_ResourcesInParent(AnalyzerTestKind kind)
+        {
+            Run(kind, static (AnalyzerAssemblyLoader loader, AssemblyLoadTestFixture testFixture) =>
+            {
+                using var temp = new TempRoot();
+                var tempDir = temp.CreateDirectory();
+                var analyzerPath = tempDir.CreateFile("AnalyzerWithLoc.dll").CopyContentFrom(testFixture.AnalyzerWithLoc).Path;
+                var analyzerResourcesPath = tempDir.CreateDirectory("es").CreateFile("AnalyzerWithLoc.resources.dll").CopyContentFrom(testFixture.AnalyzerWithLocResourceEnGB).Path;
+                loader.AddDependencyLocation(analyzerPath);
+                var assembly = loader.LoadFromPath(analyzerPath);
+                var methodInfo = assembly
+                    .GetType("AnalyzerWithLoc.Util")!
+                    .GetMethod("Exec", BindingFlags.Static | BindingFlags.Public)!;
+                methodInfo.Invoke(null, ["es-ES"]);
+
+                // The copy count is 1 here as only one real assembly was copied, the resource 
+                // dlls don't apply for this count.
+                VerifyDependencyAssemblies(loader, copyCount: 1, analyzerPath, analyzerResourcesPath);
+            });
         }
+
 #if NETCOREAPP
 
         [Theory]
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Core.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Core.cs
index 25530780cd541..5e2a1d99f08dc 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Core.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Core.cs
@@ -137,7 +137,7 @@ public DirectoryLoadContext(string directory, AnalyzerAssemblyLoader loader, Ass
                 var assemblyPath = Path.Combine(Directory, simpleName + ".dll");
                 if (_loader.IsAnalyzerDependencyPath(assemblyPath))
                 {
-                    (_, var loadPath, _) = _loader.GetAssemblyInfoForPath(assemblyPath);
+                    (_, var loadPath) = _loader.GetAssemblyInfoForPath(assemblyPath);
                     return loadCore(loadPath);
                 }
 
@@ -149,11 +149,11 @@ public DirectoryLoadContext(string directory, AnalyzerAssemblyLoader loader, Ass
                 // loader has a mode where it loads from Stream though and the runtime will not handle
                 // that automatically. Rather than bifurate our loading behavior between Disk and
                 // Stream both modes just handle satellite loading directly
-                if (!string.IsNullOrEmpty(assemblyName.CultureName) && simpleName.EndsWith(".resources", StringComparison.Ordinal))
+                if (assemblyName.CultureInfo is not null && simpleName.EndsWith(".resources", StringComparison.Ordinal))
                 {
                     var analyzerFileName = Path.ChangeExtension(simpleName, ".dll");
                     var analyzerFilePath = Path.Combine(Directory, analyzerFileName);
-                    var satelliteLoadPath = _loader.GetSatelliteInfoForPath(analyzerFilePath, assemblyName.CultureName);
+                    var satelliteLoadPath = _loader.GetRealSatelliteLoadPath(analyzerFilePath, assemblyName.CultureInfo);
                     if (satelliteLoadPath is not null)
                     {
                         return loadCore(satelliteLoadPath);
@@ -166,7 +166,8 @@ public DirectoryLoadContext(string directory, AnalyzerAssemblyLoader loader, Ass
                 // be necessary but msbuild target defaults have caused a number of customers to 
                 // fall into this path. See discussion here for where it comes up
                 // https://github.com/dotnet/roslyn/issues/56442
-                if (_loader.GetBestPath(assemblyName) is string bestRealPath)
+                var (_, bestRealPath) = _loader.GetBestPath(assemblyName);
+                if (bestRealPath is not null)
                 {
                     return loadCore(bestRealPath);
                 }
@@ -193,7 +194,7 @@ protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
                 var assemblyPath = Path.Combine(Directory, unmanagedDllName + ".dll");
                 if (_loader.IsAnalyzerDependencyPath(assemblyPath))
                 {
-                    (_, var loadPath, _) = _loader.GetAssemblyInfoForPath(assemblyPath);
+                    (_, var loadPath) = _loader.GetAssemblyInfoForPath(assemblyPath);
                     return LoadUnmanagedDllFromPath(loadPath);
                 }
 
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Desktop.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Desktop.cs
index 338a506d841e1..b4d000e335a9d 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Desktop.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.Desktop.cs
@@ -5,6 +5,7 @@
 #if !NETCOREAPP
 
 using System;
+using System.Globalization;
 using System.IO;
 using System.Reflection;
 using System.Threading;
@@ -99,11 +100,30 @@ internal bool EnsureResolvedUnhooked()
         {
             try
             {
+                const string resourcesExtension = ".resources";
                 var assemblyName = new AssemblyName(args.Name);
-                string? bestPath = GetBestPath(assemblyName);
-                if (bestPath is not null)
+                var simpleName = assemblyName.Name;
+                var isSatelliteAssembly =
+                    assemblyName.CultureInfo is not null &&
+                    simpleName.EndsWith(resourcesExtension, StringComparison.Ordinal);
+
+                if (isSatelliteAssembly)
+                {
+                    // Satellite assemblies should get the best path information using the
+                    // non-resource part of the assembly name. Once the path information is obtained
+                    // GetSatelliteInfoForPath will translate to the resource assembly path.
+                    assemblyName.Name = simpleName[..^resourcesExtension.Length];
+                }
+
+                var (originalPath, realPath) = GetBestPath(assemblyName);
+                if (isSatelliteAssembly && originalPath is not null)
+                {
+                    realPath = GetRealSatelliteLoadPath(originalPath, assemblyName.CultureInfo);
+                }
+
+                if (realPath is not null)
                 {
-                    return Assembly.LoadFrom(bestPath);
+                    return Assembly.LoadFrom(realPath);
                 }
 
                 return null;
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.cs
index 106f1c0b357d4..6ec884ede8396 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerAssemblyLoader.cs
@@ -5,11 +5,10 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Reflection;
-using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis
@@ -41,7 +40,17 @@ internal abstract partial class AnalyzerAssemblyLoader : IAnalyzerAssemblyLoader
         /// <remarks>
         /// Access must be guarded by <see cref="_guard"/>
         /// </remarks>
-        private readonly Dictionary<string, (AssemblyName? AssemblyName, string RealAssemblyPath, ImmutableHashSet<string> SatelliteCultureNames)?> _analyzerAssemblyInfoMap = new();
+        private readonly Dictionary<string, (AssemblyName? AssemblyName, string RealAssemblyPath)?> _analyzerAssemblyInfoMap = new();
+
+        /// <summary>
+        /// Mapping of analyzer dependency original full path and culture to the real satellite
+        /// assembly path. If the satellite assembly doesn't exist for the original analyzer and 
+        /// culture, the real path value stored will be null.
+        /// </summary>
+        /// <remarks>
+        /// Access must be guarded by <see cref="_guard"/>
+        /// </remarks>
+        private readonly Dictionary<(string OriginalAnalyzerPath, CultureInfo CultureInfo), string?> _analyzerSatelliteAssemblyRealPaths = new();
 
         /// <summary>
         /// Maps analyzer dependency simple names to the set of original full paths it was loaded from. This _only_ 
@@ -94,7 +103,7 @@ public void AddDependencyLocation(string fullPath)
                     _knownAssemblyPathsBySimpleName[simpleName] = paths.Add(fullPath);
                 }
 
-                // This type assumses the file system is static for the duration of the
+                // This type assumes the file system is static for the duration of the
                 // it's instance. Repeated calls to this method, even if the underlying 
                 // file system contents, should reuse the results of the first call.
                 _ = _analyzerAssemblyInfoMap.TryAdd(fullPath, null);
@@ -105,7 +114,7 @@ public Assembly LoadFromPath(string originalAnalyzerPath)
         {
             CompilerPathUtilities.RequireAbsolutePath(originalAnalyzerPath, nameof(originalAnalyzerPath));
 
-            (AssemblyName? assemblyName, _, _) = GetAssemblyInfoForPath(originalAnalyzerPath);
+            (AssemblyName? assemblyName, _) = GetAssemblyInfoForPath(originalAnalyzerPath);
 
             // Not a managed assembly, nothing else to do
             if (assemblyName is null)
@@ -132,7 +141,7 @@ public Assembly LoadFromPath(string originalAnalyzerPath)
         /// because we only want information for registered paths. Using unregistered paths inside the
         /// implementation should result in errors.
         /// </remarks>
-        protected (AssemblyName? AssemblyName, string RealAssemblyPath, ImmutableHashSet<string> SatelliteCultureNames) GetAssemblyInfoForPath(string originalAnalyzerPath)
+        protected (AssemblyName? AssemblyName, string RealAssemblyPath) GetAssemblyInfoForPath(string originalAnalyzerPath)
         {
             lock (_guard)
             {
@@ -147,8 +156,7 @@ public Assembly LoadFromPath(string originalAnalyzerPath)
                 }
             }
 
-            var resourceAssemblyCultureNames = getResourceAssemblyCultureNames(originalAnalyzerPath);
-            string realPath = PreparePathToLoad(originalAnalyzerPath, resourceAssemblyCultureNames);
+            string realPath = PreparePathToLoad(originalAnalyzerPath);
             AssemblyName? assemblyName;
             try
             {
@@ -164,64 +172,77 @@ public Assembly LoadFromPath(string originalAnalyzerPath)
 
             lock (_guard)
             {
-                _analyzerAssemblyInfoMap[originalAnalyzerPath] = (assemblyName, realPath, resourceAssemblyCultureNames);
+                _analyzerAssemblyInfoMap[originalAnalyzerPath] = (assemblyName, realPath);
             }
 
-            return (assemblyName, realPath, resourceAssemblyCultureNames);
+            return (assemblyName, realPath);
+        }
+
+        /// <summary>
+        /// Get the path a satellite assembly should be loaded from for the given original 
+        /// analyzer path and culture
+        /// </summary>
+        /// <remarks>
+        /// This is used during assembly resolve for satellite assemblies to determine the
+        /// path from where the satellite assembly should be loaded for the specified culture.
+        /// This method calls <see cref="PrepareSatelliteAssemblyToLoad"/> to ensure this path
+        /// contains the satellite assembly.
+        /// </remarks>
+        internal string? GetRealSatelliteLoadPath(string originalAnalyzerPath, CultureInfo cultureInfo)
+        {
+            string? realSatelliteAssemblyPath = null;
 
-            // Discover the culture names for any satellite dlls related to this analyzer. These 
-            // need to be understood when handling the resource loading in certain cases.
-            static ImmutableHashSet<string> getResourceAssemblyCultureNames(string originalAnalyzerPath)
+            lock (_guard)
             {
-                var path = Path.GetDirectoryName(originalAnalyzerPath)!;
-                using var enumerator = Directory.EnumerateDirectories(path, "*").GetEnumerator();
-                if (!enumerator.MoveNext())
+                if (_analyzerSatelliteAssemblyRealPaths.TryGetValue((originalAnalyzerPath, cultureInfo), out realSatelliteAssemblyPath))
                 {
-                    return ImmutableHashSet<string>.Empty;
+                    return realSatelliteAssemblyPath;
                 }
+            }
+
+            var actualCultureName = getSatelliteCultureName(originalAnalyzerPath, cultureInfo);
+            if (actualCultureName != null)
+            {
+                realSatelliteAssemblyPath = PrepareSatelliteAssemblyToLoad(originalAnalyzerPath, actualCultureName);
+            }
+
+            lock (_guard)
+            {
+                _analyzerSatelliteAssemblyRealPaths[(originalAnalyzerPath, cultureInfo)] = realSatelliteAssemblyPath;
+            }
+
+            return realSatelliteAssemblyPath;
 
+            // Discover the most specific culture name to use for the specified analyzer path and culture
+            static string? getSatelliteCultureName(string originalAnalyzerPath, CultureInfo cultureInfo)
+            {
+                var path = Path.GetDirectoryName(originalAnalyzerPath)!;
                 var resourceFileName = GetSatelliteFileName(Path.GetFileName(originalAnalyzerPath));
-                var builder = ImmutableHashSet.CreateBuilder<string>(StringComparer.OrdinalIgnoreCase);
-                do
+
+                while (cultureInfo != CultureInfo.InvariantCulture)
                 {
-                    var resourceFilePath = Path.Combine(enumerator.Current, resourceFileName);
+                    var resourceFilePath = Path.Combine(path, cultureInfo.Name, resourceFileName);
+
                     if (File.Exists(resourceFilePath))
                     {
-                        builder.Add(Path.GetFileName(enumerator.Current));
+                        return cultureInfo.Name;
                     }
-                }
-                while (enumerator.MoveNext());
 
-                return builder.ToImmutableHashSet();
-            }
-        }
+                    cultureInfo = cultureInfo.Parent;
+                }
 
-        /// <summary>
-        /// Get the real load path of the satellite assembly given the original path to the analyzer 
-        /// and the desired culture name.
-        /// </summary>
-        protected string? GetSatelliteInfoForPath(string originalAnalyzerPath, string cultureName)
-        {
-            var (_, realAssemblyPath, satelliteCultureNames) = GetAssemblyInfoForPath(originalAnalyzerPath);
-            if (!satelliteCultureNames.Contains(cultureName))
-            {
                 return null;
             }
-
-            var satelliteFileName = GetSatelliteFileName(Path.GetFileName(realAssemblyPath));
-            var dir = Path.GetDirectoryName(realAssemblyPath)!;
-            return Path.Combine(dir, cultureName, satelliteFileName);
         }
 
         /// <summary>
-        /// Return the best path for loading an assembly with the specified <see cref="AssemblyName"/>. This
-        /// return is a real path to load, not an original path.
+        /// Return the best (original, real) path information for loading an assembly with the specified <see cref="AssemblyName"/>.
         /// </summary>
-        protected string? GetBestPath(AssemblyName requestedName)
+        protected (string? BestOriginalPath, string? BestRealPath) GetBestPath(AssemblyName requestedName)
         {
             if (requestedName.Name is null)
             {
-                return null;
+                return (null, null);
             }
 
             ImmutableHashSet<string>? paths;
@@ -229,17 +250,18 @@ static ImmutableHashSet<string> getResourceAssemblyCultureNames(string originalA
             {
                 if (!_knownAssemblyPathsBySimpleName.TryGetValue(requestedName.Name, out paths))
                 {
-                    return null;
+                    return (null, null);
                 }
             }
 
             // Sort the candidate paths by ordinal, to ensure determinism with the same inputs if you were to have
             // multiple assemblies providing the same version.
-            string? bestPath = null;
+            string? bestRealPath = null;
+            string? bestOriginalPath = null;
             AssemblyName? bestName = null;
             foreach (var candidateOriginalPath in paths.OrderBy(StringComparer.Ordinal))
             {
-                (AssemblyName? candidateName, string candidateRealPath, _) = GetAssemblyInfoForPath(candidateOriginalPath);
+                (AssemblyName? candidateName, string candidateRealPath) = GetAssemblyInfoForPath(candidateOriginalPath);
                 if (candidateName is null)
                 {
                     continue;
@@ -249,18 +271,19 @@ static ImmutableHashSet<string> getResourceAssemblyCultureNames(string originalA
                 {
                     if (candidateName.Version == requestedName.Version)
                     {
-                        return candidateRealPath;
+                        return (candidateOriginalPath, candidateRealPath);
                     }
 
                     if (bestName is null || candidateName.Version > bestName.Version)
                     {
-                        bestPath = candidateRealPath;
+                        bestOriginalPath = candidateOriginalPath;
+                        bestRealPath = candidateRealPath;
                         bestName = candidateName;
                     }
                 }
             }
 
-            return bestPath;
+            return (bestOriginalPath, bestRealPath);
         }
 
         protected static string GetSatelliteFileName(string assemblyFileName) =>
@@ -270,15 +293,18 @@ protected static string GetSatelliteFileName(string assemblyFileName) =>
         /// When overridden in a derived class, allows substituting an assembly path after we've
         /// identified the context to load an assembly in, but before the assembly is actually
         /// loaded from disk. This is used to substitute out the original path with the shadow-copied version.
-        /// 
-        /// In the case the <param name="assemblyFilePath" /> is moved to a new location then 
-        /// the resource DLLs for the specified <paramref name="resourceAssemblyCultureNames"/> must also be 
-        /// moved _but_ retain their original relative location.
         /// </summary>
-        protected abstract string PreparePathToLoad(string assemblyFilePath, ImmutableHashSet<string> resourceAssemblyCultureNames);
+        protected abstract string PreparePathToLoad(string assemblyFilePath);
+
+        /// <summary>
+        /// When overridden in a derived class, allows substituting a satellite assembly path after we've
+        /// identified the context to load a satellite assembly in, but before the satellite assembly is actually
+        /// loaded from disk. This is used to substitute out the original path with the shadow-copied version.
+        /// </summary>
+        protected abstract string PrepareSatelliteAssemblyToLoad(string assemblyFilePath, string cultureName);
 
         /// <summary>
-        /// When <see cref="PreparePathToLoad(string, ImmutableHashSet{string})"/> is overridden this returns the most recent
+        /// When <see cref="PreparePathToLoad(string)"/> is overridden this returns the most recent
         /// real path calculated for the <paramref name="originalFullPath"/>
         /// </summary>
         internal string GetRealAnalyzerLoadPath(string originalFullPath)
@@ -294,30 +320,6 @@ internal string GetRealAnalyzerLoadPath(string originalFullPath)
             }
         }
 
-        /// <summary>
-        /// When <see cref="PreparePathToLoad(string, ImmutableHashSet{string})"/> is overridden this returns the most recent
-        /// real path for the given analyzer satellite assembly path
-        /// </summary>
-        internal string? GetRealSatelliteLoadPath(string originalSatelliteFullPath)
-        {
-            // This is a satellite assembly, need to find the mapped path of the real assembly, then 
-            // adjust that mapped path for the suffix of the satellite assembly
-            //
-            // Example of dll and it's corresponding satellite assembly
-            //
-            //  c:\some\path\en-GB\util.resources.dll
-            //  c:\some\path\util.dll
-            var assemblyFileName = Path.ChangeExtension(Path.GetFileNameWithoutExtension(originalSatelliteFullPath), ".dll");
-
-            var assemblyDir = Path.GetDirectoryName(originalSatelliteFullPath)!;
-            var cultureName = Path.GetFileName(assemblyDir);
-            assemblyDir = Path.GetDirectoryName(assemblyDir)!;
-
-            // Real assembly is located in the directory above this one
-            var assemblyPath = Path.Combine(assemblyDir, assemblyFileName);
-            return GetSatelliteInfoForPath(assemblyPath, cultureName);
-        }
-
         internal (string OriginalAssemblyPath, string RealAssemblyPath)[] GetPathMapSnapshot()
         {
             lock (_guard)
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs
index 10ebd0c290689..624768168d521 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs
@@ -32,7 +32,18 @@ internal DefaultAnalyzerAssemblyLoader(System.Runtime.Loader.AssemblyLoadContext
         /// <summary>
         /// The default implementation is to simply load in place.
         /// </summary>
-        protected override string PreparePathToLoad(string fullPath, ImmutableHashSet<string> satelliteCultureNames) => fullPath;
+        protected override string PreparePathToLoad(string fullPath) => fullPath;
+
+        /// <summary>
+        /// The default implementation is to simply load in place.
+        /// </summary>
+        protected override string PrepareSatelliteAssemblyToLoad(string assemblyFilePath, string cultureName)
+        {
+            var directory = Path.GetDirectoryName(assemblyFilePath)!;
+            var fileName = GetSatelliteFileName(Path.GetFileName(assemblyFilePath));
+
+            return Path.Combine(directory, cultureName, fileName);
+        }
 
         /// <summary>
         /// Return an <see cref="IAnalyzerAssemblyLoader"/> which does not lock assemblies on disk that is
diff --git a/src/Compilers/Core/Portable/DiagnosticAnalyzer/ShadowCopyAnalyzerAssemblyLoader.cs b/src/Compilers/Core/Portable/DiagnosticAnalyzer/ShadowCopyAnalyzerAssemblyLoader.cs
index db53a1ae198fc..40592947a8ac4 100644
--- a/src/Compilers/Core/Portable/DiagnosticAnalyzer/ShadowCopyAnalyzerAssemblyLoader.cs
+++ b/src/Compilers/Core/Portable/DiagnosticAnalyzer/ShadowCopyAnalyzerAssemblyLoader.cs
@@ -6,13 +6,9 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Collections.Immutable;
 using Roslyn.Utilities;
-using System.Reflection.PortableExecutable;
-using System.Reflection.Metadata;
 
 #if NETCOREAPP
 using System.Runtime.Loader;
@@ -39,6 +35,7 @@ internal sealed class ShadowCopyAnalyzerAssemblyLoader : AnalyzerAssemblyLoader
         private readonly Lazy<(string directory, Mutex)> _shadowCopyDirectoryAndMutex;
 
         private readonly ConcurrentDictionary<Guid, Task<string>> _mvidPathMap = new ConcurrentDictionary<Guid, Task<string>>();
+        private readonly ConcurrentDictionary<(Guid, string), Task<string>> _mvidSatelliteAssemblyPathMap = new ConcurrentDictionary<(Guid, string), Task<string>>();
 
         internal string BaseDirectory => _baseDirectory;
 
@@ -129,22 +126,62 @@ private void DeleteLeftoverDirectories()
             }
         }
 
-        protected override string PreparePathToLoad(string originalAnalyzerPath, ImmutableHashSet<string> cultureNames)
+        protected override string PreparePathToLoad(string originalAnalyzerPath)
         {
             var mvid = AssemblyUtilities.ReadMvid(originalAnalyzerPath);
-            if (_mvidPathMap.TryGetValue(mvid, out Task<string>? copyTask))
+
+            return PrepareLoad(_mvidPathMap, mvid, copyAnalyzerContents);
+
+            string copyAnalyzerContents()
+            {
+                var analyzerFileName = Path.GetFileName(originalAnalyzerPath);
+                var shadowDirectory = Path.Combine(_shadowCopyDirectoryAndMutex.Value.directory, mvid.ToString());
+                var shadowAnalyzerPath = Path.Combine(shadowDirectory, analyzerFileName);
+                CopyFile(originalAnalyzerPath, shadowAnalyzerPath);
+
+                return shadowAnalyzerPath;
+            }
+        }
+
+        protected override string PrepareSatelliteAssemblyToLoad(string originalAnalyzerPath, string cultureName)
+        {
+            var mvid = AssemblyUtilities.ReadMvid(originalAnalyzerPath);
+
+            return PrepareLoad(_mvidSatelliteAssemblyPathMap, (mvid, cultureName), copyAnalyzerContents);
+
+            string copyAnalyzerContents()
+            {
+                var analyzerFileName = Path.GetFileName(originalAnalyzerPath);
+                var shadowDirectory = Path.Combine(_shadowCopyDirectoryAndMutex.Value.directory, mvid.ToString());
+                var shadowAnalyzerPath = Path.Combine(shadowDirectory, analyzerFileName);
+
+                var originalDirectory = Path.GetDirectoryName(originalAnalyzerPath)!;
+                var satelliteFileName = GetSatelliteFileName(analyzerFileName);
+
+                var originalSatellitePath = Path.Combine(originalDirectory, cultureName, satelliteFileName);
+                var shadowSatellitePath = Path.Combine(shadowDirectory, cultureName, satelliteFileName);
+                CopyFile(originalSatellitePath, shadowSatellitePath);
+
+                return shadowSatellitePath;
+            }
+        }
+
+        private static string PrepareLoad<TKey>(ConcurrentDictionary<TKey, Task<string>> mvidPathMap, TKey mvidKey, Func<string> copyContents)
+            where TKey : notnull
+        {
+            if (mvidPathMap.TryGetValue(mvidKey, out Task<string>? copyTask))
             {
                 return copyTask.Result;
             }
 
             var tcs = new TaskCompletionSource<string>();
-            var task = _mvidPathMap.GetOrAdd(mvid, tcs.Task);
+            var task = mvidPathMap.GetOrAdd(mvidKey, tcs.Task);
             if (object.ReferenceEquals(task, tcs.Task))
             {
                 // This thread won and we need to do the copy.
                 try
                 {
-                    var shadowAnalyzerPath = copyAnalyzerContents();
+                    var shadowAnalyzerPath = copyContents();
                     tcs.SetResult(shadowAnalyzerPath);
                     return shadowAnalyzerPath;
                 }
@@ -159,43 +196,19 @@ protected override string PreparePathToLoad(string originalAnalyzerPath, Immutab
                 // This thread lost and we need to wait for the winner to finish the copy.
                 return task.Result;
             }
+        }
 
-            string copyAnalyzerContents()
+        private static void CopyFile(string originalPath, string shadowCopyPath)
+        {
+            var directory = Path.GetDirectoryName(shadowCopyPath);
+            if (directory is null)
             {
-                var analyzerFileName = Path.GetFileName(originalAnalyzerPath);
-                var shadowDirectory = Path.Combine(_shadowCopyDirectoryAndMutex.Value.directory, mvid.ToString());
-                var shadowAnalyzerPath = Path.Combine(shadowDirectory, analyzerFileName);
-                copyFile(originalAnalyzerPath, shadowAnalyzerPath);
-
-                if (cultureNames.IsEmpty)
-                {
-                    return shadowAnalyzerPath;
-                }
-
-                var originalDirectory = Path.GetDirectoryName(originalAnalyzerPath)!;
-                var satelliteFileName = GetSatelliteFileName(analyzerFileName);
-                foreach (var cultureName in cultureNames)
-                {
-                    var originalSatellitePath = Path.Combine(originalDirectory, cultureName, satelliteFileName);
-                    var shadowSatellitePath = Path.Combine(shadowDirectory, cultureName, satelliteFileName);
-                    copyFile(originalSatellitePath, shadowSatellitePath);
-                }
-
-                return shadowAnalyzerPath;
+                throw new ArgumentException($"Shadow copy path '{shadowCopyPath}' must not be the root directory");
             }
 
-            static void copyFile(string originalPath, string shadowCopyPath)
-            {
-                var directory = Path.GetDirectoryName(shadowCopyPath);
-                if (directory is null)
-                {
-                    throw new ArgumentException($"Shadow copy path '{shadowCopyPath}' must not be the root directory");
-                }
-
-                _ = Directory.CreateDirectory(directory);
-                File.Copy(originalPath, shadowCopyPath);
-                ClearReadOnlyFlagOnFile(new FileInfo(shadowCopyPath));
-            }
+            _ = Directory.CreateDirectory(directory);
+            File.Copy(originalPath, shadowCopyPath);
+            ClearReadOnlyFlagOnFile(new FileInfo(shadowCopyPath));
         }
 
         private static void ClearReadOnlyFlagOnFiles(string directoryPath)
diff --git a/src/VisualStudio/Core/Test.Next/Remote/SnapshotSerializationTests.cs b/src/VisualStudio/Core/Test.Next/Remote/SnapshotSerializationTests.cs
index c0758bc51aeb3..44e0d9b7ccaaa 100644
--- a/src/VisualStudio/Core/Test.Next/Remote/SnapshotSerializationTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Remote/SnapshotSerializationTests.cs
@@ -709,7 +709,10 @@ private static AnalyzerFileReference CreateShadowCopiedAnalyzerReference(TempRoo
 
         private class MissingAnalyzerLoader : AnalyzerAssemblyLoader
         {
-            protected override string PreparePathToLoad(string fullPath, ImmutableHashSet<string> cultureNames)
+            protected override string PreparePathToLoad(string fullPath)
+                => throw new FileNotFoundException(fullPath);
+
+            protected override string PrepareSatelliteAssemblyToLoad(string fullPath, string cultureName)
                 => throw new FileNotFoundException(fullPath);
         }
 
diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteAnalyzerAssemblyLoader.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteAnalyzerAssemblyLoader.cs
index 108cdd343422f..7417225aaebba 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/RemoteAnalyzerAssemblyLoader.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteAnalyzerAssemblyLoader.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Collections.Immutable;
 using System.IO;
 
 namespace Microsoft.CodeAnalysis.Remote.Diagnostics
@@ -21,10 +20,16 @@ public RemoteAnalyzerAssemblyLoader(string baseDirectory)
             _baseDirectory = baseDirectory;
         }
 
-        protected override string PreparePathToLoad(string fullPath, ImmutableHashSet<string> cultureNames)
+        protected override string PreparePathToLoad(string fullPath)
         {
             var fixedPath = Path.GetFullPath(Path.Combine(_baseDirectory, Path.GetFileName(fullPath)));
             return File.Exists(fixedPath) ? fixedPath : fullPath;
         }
+
+        protected override string PrepareSatelliteAssemblyToLoad(string fullPath, string cultureName)
+        {
+            var fixedPath = Path.GetFullPath(Path.Combine(_baseDirectory, cultureName, Path.GetFileName(fullPath)));
+            return File.Exists(fixedPath) ? fixedPath : fullPath;
+        }
     }
 }

From 05f015c78f6012877a6b25d08f9a81c0dd96aeb0 Mon Sep 17 00:00:00 2001
From: DoctorKrolic <70431552+DoctorKrolic@users.noreply.github.com>
Date: Tue, 19 Mar 2024 18:19:20 +0300
Subject: [PATCH 119/170] Improve code gen for concatenation of `string` and
 `char` (#71793)

Closes https://github.com/dotnet/roslyn/issues/66827
---
 .../CSharp/Portable/CodeGen/EmitExpression.cs |    9 +-
 .../FlowAnalysis/DefiniteAssignment.cs        |    3 +-
 .../FlowAnalysis/EmptyStructTypeCache.cs      |    8 +-
 .../Portable/FlowAnalysis/NullableWalker.cs   |    2 +-
 .../DiagnosticsPass_ExpressionTrees.cs        |    2 +-
 .../Lowering/LocalRewriter/LocalRewriter.cs   |    8 +-
 .../LocalRewriter/LocalRewriter_Conversion.cs |    2 +-
 .../LocalRewriter/LocalRewriter_Event.cs      |    8 +-
 .../LocalRewriter_FixedStatement.cs           |    4 +-
 .../LocalRewriter_LockStatement.cs            |    6 +-
 .../LocalRewriter_ObjectCreationExpression.cs |    2 +-
 .../LocalRewriter/LocalRewriter_StackAlloc.cs |    2 +-
 .../LocalRewriter_StringConcat.cs             |  287 +-
 .../Portable/Lowering/SpillSequenceSpiller.cs |   23 +-
 .../MethodToStateMachineRewriter.cs           |    3 +-
 .../Symbols/Metadata/PE/PENamedTypeSymbol.cs  |   35 +-
 .../Portable/Symbols/TypeSymbolExtensions.cs  |    3 +-
 .../CodeGenSpanBasedStringConcatTests.cs      | 5715 +++++++++++++++++
 .../Symbols/CompilationCreationTests.cs       |    3 +-
 .../Symbols/Metadata/PE/LoadingFields.cs      |   16 +-
 .../Symbol/Symbols/MissingSpecialMember.cs    |   12 +-
 .../Symbols/Source/ClsComplianceTests.cs      |    2 +-
 .../Core/Portable/PublicAPI.Shipped.txt       |    2 +-
 .../Core/Portable/PublicAPI.Unshipped.txt     |    1 +
 src/Compilers/Core/Portable/SpecialMember.cs  |    8 +
 src/Compilers/Core/Portable/SpecialMembers.cs |   71 +
 src/Compilers/Core/Portable/SpecialType.cs    |   15 +-
 .../Core/Portable/SpecialTypeExtensions.cs    |   11 +
 src/Compilers/Core/Portable/SpecialTypes.cs   |    1 +
 .../Core/Portable/WellKnownMembers.cs         |    6 +-
 src/Compilers/Core/Portable/WellKnownTypes.cs |    5 +-
 .../Analysis/FlowAnalysis/AbstractFlowPass.vb |   39 +-
 .../Symbols/Metadata/PE/PENamedTypeSymbol.vb  |   37 +-
 .../SymbolsTests/CompilationCreationTests.vb  |    3 +-
 .../SymbolsTests/Metadata/PE/LoadingFields.vb |   18 +-
 .../WellKnownTypeValidationTests.vb           |   13 +-
 36 files changed, 6281 insertions(+), 104 deletions(-)
 create mode 100644 src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs

diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
index a01873aa52b36..1a4fae886824a 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
@@ -2294,9 +2294,12 @@ internal static bool MayUseCallForStructMethod(MethodSymbol method)
             }
 
             var containingType = method.ContainingType;
-            // overrides in structs that are special types can be called directly.
-            // we can assume that special types will not be removing overrides
-            return containingType.SpecialType != SpecialType.None;
+            // Overrides in structs of some special types can be called directly.
+            // We can assume that these special types will not be removing overrides.
+            // This pattern can probably be applied to all special types,
+            // but that would introduce a silent change every time a new special type is added,
+            // so we constrain the check to a fixed range of types
+            return containingType.SpecialType.CanOptimizeBehavior();
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
index fb7e7fe234c61..67cae8265b05e 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
@@ -17,7 +17,6 @@
 #define REFERENCE_STATE
 #endif
 
-using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -362,7 +361,7 @@ protected override ImmutableArray<PendingBranch> Scan(ref bool badRegion)
             if ((object)methodThisParameter != null)
             {
                 EnterParameter(methodThisParameter);
-                if (methodThisParameter.Type.SpecialType != SpecialType.None)
+                if (methodThisParameter.Type.SpecialType.CanOptimizeBehavior())
                 {
                     int slot = GetOrCreateSlot(methodThisParameter);
                     SetSlotState(slot, true);
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/EmptyStructTypeCache.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/EmptyStructTypeCache.cs
index 8a09d4519c02a..ba93a2a660399 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/EmptyStructTypeCache.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/EmptyStructTypeCache.cs
@@ -4,16 +4,10 @@
 
 #nullable disable
 
-using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Text;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
-using System.Threading;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -131,7 +125,7 @@ public static bool IsTrackableStructType(TypeSymbol type)
             if ((object)type == null) return false;
             var nts = type.OriginalDefinition as NamedTypeSymbol;
             if ((object)nts == null) return false;
-            return nts.IsStructType() && nts.SpecialType == SpecialType.None && !nts.KnownCircularStruct;
+            return nts.IsStructType() && !nts.SpecialType.CanOptimizeBehavior() && !nts.KnownCircularStruct;
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
index 552a45e0a15b9..5f7eacbfddf06 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -4322,7 +4322,7 @@ protected override bool IsEmptyStructType(TypeSymbol type)
                 return false;
             }
 
-            if (type.SpecialType != SpecialType.None)
+            if (type.SpecialType.CanOptimizeBehavior())
             {
                 return true;
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
index 712657a43d62a..1f401b2ef6eff 100644
--- a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
@@ -90,7 +90,7 @@ public override BoundNode VisitArrayAccess(BoundArrayAccess node)
         {
             if (_inExpressionLambda &&
                 node.Indices.Length == 1 &&
-                node.Indices[0].Type!.SpecialType == SpecialType.None)
+                !node.Indices[0].Type!.SpecialType.CanOptimizeBehavior())
             {
                 Error(ErrorCode.ERR_ExpressionTreeContainsPatternImplicitIndexer, node);
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
index 33a63f198d00e..b97db610386a9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
@@ -593,11 +593,11 @@ private static BoundExpression BadExpression(SyntaxNode syntax, TypeSymbol resul
             return new BoundBadExpression(syntax, LookupResultKind.NotReferencable, ImmutableArray<Symbol?>.Empty, children, resultType);
         }
 
-        private bool TryGetWellKnownTypeMember<TSymbol>(SyntaxNode? syntax, WellKnownMember member, out TSymbol symbol, bool isOptional = false, Location? location = null) where TSymbol : Symbol
+        private bool TryGetWellKnownTypeMember<TSymbol>(SyntaxNode? syntax, WellKnownMember member, [NotNullWhen(true)] out TSymbol? symbol, bool isOptional = false, Location? location = null) where TSymbol : Symbol
         {
             Debug.Assert((syntax != null) ^ (location != null));
 
-            symbol = (TSymbol)Binder.GetWellKnownTypeMember(_compilation, member, _diagnostics, syntax: syntax, isOptional: isOptional, location: location);
+            symbol = (TSymbol?)Binder.GetWellKnownTypeMember(_compilation, member, _diagnostics, syntax: syntax, isOptional: isOptional, location: location);
             return symbol is { };
         }
 
@@ -652,7 +652,7 @@ public override BoundNode VisitTypeOfOperator(BoundTypeOfOperator node)
             var type = this.VisitType(node.Type);
 
             // Emit needs this helper
-            MethodSymbol getTypeFromHandle;
+            MethodSymbol? getTypeFromHandle;
             if (!TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Type__GetTypeFromHandle, out getTypeFromHandle))
             {
                 return new BoundTypeOfOperator(node.Syntax, sourceType, null, type, hasErrors: true);
@@ -669,7 +669,7 @@ public override BoundNode VisitRefTypeOperator(BoundRefTypeOperator node)
             var type = this.VisitType(node.Type);
 
             // Emit needs this helper
-            MethodSymbol getTypeFromHandle;
+            MethodSymbol? getTypeFromHandle;
             if (!TryGetWellKnownTypeMember(node.Syntax, WellKnownMember.System_Type__GetTypeFromHandle, out getTypeFromHandle))
             {
                 return new BoundRefTypeOperator(node.Syntax, operand, null, type, hasErrors: true);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index b0f418eec38f4..635043ef290bd 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -106,7 +106,7 @@ private BoundExpression MakeUtf8Span(BoundExpression node, IReadOnlyList<byte>?
                                             BadExpression(node.Syntax, byteArray, ImmutableArray<BoundExpression>.Empty) :
                                             MakeUnderlyingArrayForUtf8Span(node.Syntax, byteArray, bytes, out length);
 
-            if (!TryGetWellKnownTypeMember<MethodSymbol>(node.Syntax, WellKnownMember.System_ReadOnlySpan_T__ctor_Array_Start_Length, out MethodSymbol ctor))
+            if (!TryGetWellKnownTypeMember<MethodSymbol>(node.Syntax, WellKnownMember.System_ReadOnlySpan_T__ctor_Array_Start_Length, out MethodSymbol? ctor))
             {
                 result = BadExpression(node.Syntax, node.Type, ImmutableArray<BoundExpression>.Empty);
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Event.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Event.cs
index 2230f563e551a..0a9644a25fe6b 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Event.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Event.cs
@@ -113,7 +113,7 @@ private BoundExpression RewriteWindowsRuntimeEventAssignmentOperator(SyntaxNode
             BoundExpression? clearCall = null;
             if (kind == EventAssignmentKind.Assignment)
             {
-                MethodSymbol clearMethod;
+                MethodSymbol? clearMethod;
                 if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_WindowsRuntimeMarshal__RemoveAllEventHandlers, out clearMethod))
                 {
                     clearCall = MakeCall(
@@ -154,7 +154,7 @@ private BoundExpression RewriteWindowsRuntimeEventAssignmentOperator(SyntaxNode
 
             BoundExpression marshalCall;
 
-            MethodSymbol marshalMethod;
+            MethodSymbol? marshalMethod;
             if (TryGetWellKnownTypeMember(syntax, helper, out marshalMethod))
             {
                 marshalMethod = marshalMethod.Construct(eventType);
@@ -248,7 +248,7 @@ private BoundExpression MakeEventAccess(
 
             BoundExpression getOrCreateCall;
 
-            MethodSymbol getOrCreateMethod;
+            MethodSymbol? getOrCreateMethod;
             if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationTokenTable_T__GetOrCreateEventRegistrationTokenTable, out getOrCreateMethod))
             {
                 getOrCreateMethod = getOrCreateMethod.AsMember(fieldType);
@@ -266,7 +266,7 @@ private BoundExpression MakeEventAccess(
                 getOrCreateCall = new BoundBadExpression(syntax, LookupResultKind.NotInvocable, ImmutableArray<Symbol?>.Empty, ImmutableArray.Create<BoundExpression>(fieldAccess), ErrorTypeSymbol.UnknownResultType);
             }
 
-            PropertySymbol invocationListProperty;
+            PropertySymbol? invocationListProperty;
             if (TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Runtime_InteropServices_WindowsRuntime_EventRegistrationTokenTable_T__InvocationList, out invocationListProperty))
             {
                 MethodSymbol invocationListAccessor = invocationListProperty.GetMethod;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_FixedStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_FixedStatement.cs
index 3de6918805b93..669f89e230748 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_FixedStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_FixedStatement.cs
@@ -473,7 +473,7 @@ private BoundStatement InitializeFixedStatementStringLocal(
             BoundExpression notNullCheck = _factory.MakeNullCheck(factory.Syntax, factory.Local(localSymbol), BinaryOperatorKind.NotEqual);
             BoundExpression helperCall;
 
-            MethodSymbol offsetMethod;
+            MethodSymbol? offsetMethod;
             if (TryGetWellKnownTypeMember(fixedInitializer.Syntax, WellKnownMember.System_Runtime_CompilerServices_RuntimeHelpers__get_OffsetToStringData, out offsetMethod))
             {
                 helperCall = factory.Call(receiver: null, method: offsetMethod);
@@ -534,7 +534,7 @@ private BoundStatement InitializeFixedStatementArrayLocal(
             }
             else
             {
-                MethodSymbol lengthMethod;
+                MethodSymbol? lengthMethod;
                 if (TryGetWellKnownTypeMember(fixedInitializer.Syntax, WellKnownMember.System_Array__get_Length, out lengthMethod))
                 {
                     lengthCall = factory.Call(factory.Local(pinnedTemp), lengthMethod);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_LockStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_LockStatement.cs
index eebe254102294..7e90157dc9e37 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_LockStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_LockStatement.cs
@@ -100,7 +100,7 @@ public override BoundNode VisitLockStatement(BoundLockStatement node)
             BoundStatement boundLockTempInit = new BoundExpressionStatement(lockSyntax, assignmentToLockTemp);
             BoundExpression exitCallExpr;
 
-            MethodSymbol exitMethod;
+            MethodSymbol? exitMethod;
             if (TryGetWellKnownTypeMember(lockSyntax, WellKnownMember.System_Threading_Monitor__Exit, out exitMethod))
             {
                 exitCallExpr = BoundCall.Synthesized(
@@ -117,7 +117,7 @@ public override BoundNode VisitLockStatement(BoundLockStatement node)
 
             BoundStatement exitCall = new BoundExpressionStatement(lockSyntax, exitCallExpr);
 
-            MethodSymbol enterMethod;
+            MethodSymbol? enterMethod;
 
             if ((TryGetWellKnownTypeMember(lockSyntax, WellKnownMember.System_Threading_Monitor__Enter2, out enterMethod, isOptional: true) ||
                  TryGetWellKnownTypeMember(lockSyntax, WellKnownMember.System_Threading_Monitor__Enter, out enterMethod)) && // If we didn't find the overload introduced in .NET 4.0, then use the older one. 
@@ -195,7 +195,7 @@ public override BoundNode VisitLockStatement(BoundLockStatement node)
 
                 BoundExpression enterCallExpr;
 
-                if ((object)enterMethod != null)
+                if ((object?)enterMethod != null)
                 {
                     Debug.Assert(enterMethod.ParameterCount == 1);
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
index 13f59f7b5e44a..dd6498eef7b0d 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
@@ -330,7 +330,7 @@ private BoundExpression MakeNewT(SyntaxNode syntax, TypeParameterSymbol typePara
             // if struct defines one.
             // Since we cannot know if T has a parameterless constructor statically, 
             // we must call Activator.CreateInstance unconditionally.
-            MethodSymbol method;
+            MethodSymbol? method;
 
             if (!this.TryGetWellKnownTypeMember(syntax, WellKnownMember.System_Activator__CreateInstance_T, out method))
             {
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StackAlloc.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StackAlloc.cs
index 4ce952d314474..012a1bd23dd31 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StackAlloc.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StackAlloc.cs
@@ -58,7 +58,7 @@ private BoundNode VisitStackAllocArrayCreationBase(BoundStackAllocArrayCreationB
                     stackAllocNode.Syntax, elementType, stackSize, initializerOpt, _compilation.CreatePointerTypeSymbol(elementType));
 
                 BoundExpression constructorCall;
-                if (TryGetWellKnownTypeMember(stackAllocNode.Syntax, WellKnownMember.System_Span_T__ctor_Pointer, out MethodSymbol spanConstructor))
+                if (TryGetWellKnownTypeMember(stackAllocNode.Syntax, WellKnownMember.System_Span_T__ctor_Pointer, out MethodSymbol? spanConstructor))
                 {
                     constructorCall = _factory.New((MethodSymbol)spanConstructor.SymbolAsMember(spanType), stackAllocNode, countTemp);
                 }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs
index 9dbcb2383016a..9b0daebe8a387 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_StringConcat.cs
@@ -4,6 +4,7 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -79,7 +80,7 @@ private BoundExpression RewriteStringConcatenation(SyntaxNode syntax, BinaryOper
             leftFlattened.AddRange(rightFlattened);
             rightFlattened.Free();
 
-            BoundExpression result;
+            BoundExpression? result;
 
             switch (leftFlattened.Count)
             {
@@ -96,7 +97,11 @@ private BoundExpression RewriteStringConcatenation(SyntaxNode syntax, BinaryOper
                 case 2:
                     var left = leftFlattened[0];
                     var right = leftFlattened[1];
-                    result = RewriteStringConcatenationTwoExprs(syntax, left, right);
+
+                    if (!TryRewriteStringConcatenationWithSpanBasedConcat(syntax, leftFlattened, out result))
+                    {
+                        result = RewriteStringConcatenationTwoExprs(syntax, left, right);
+                    }
                     break;
 
                 case 3:
@@ -104,7 +109,11 @@ private BoundExpression RewriteStringConcatenation(SyntaxNode syntax, BinaryOper
                         var first = leftFlattened[0];
                         var second = leftFlattened[1];
                         var third = leftFlattened[2];
-                        result = RewriteStringConcatenationThreeExprs(syntax, first, second, third);
+
+                        if (!TryRewriteStringConcatenationWithSpanBasedConcat(syntax, leftFlattened, out result))
+                        {
+                            result = RewriteStringConcatenationThreeExprs(syntax, first, second, third);
+                        }
                     }
                     break;
 
@@ -114,7 +123,11 @@ private BoundExpression RewriteStringConcatenation(SyntaxNode syntax, BinaryOper
                         var second = leftFlattened[1];
                         var third = leftFlattened[2];
                         var fourth = leftFlattened[3];
-                        result = RewriteStringConcatenationFourExprs(syntax, first, second, third, fourth);
+
+                        if (!TryRewriteStringConcatenationWithSpanBasedConcat(syntax, leftFlattened, out result))
+                        {
+                            result = RewriteStringConcatenationFourExprs(syntax, first, second, third, fourth);
+                        }
                     }
                     break;
 
@@ -150,13 +163,12 @@ private void FlattenConcatArg(BoundExpression lowered, ArrayBuilder<BoundExpress
         /// Determines whether an expression is a known string concat operator (with or without a subsequent ?? ""), and extracts
         /// its args if so.
         /// </summary>
-        /// <returns>True if this is a call to a known string concat operator, false otherwise</returns>
+        /// <returns>True if this is a call to a known string concat operator and its arguments are successfully extracted, false otherwise</returns>
         private bool TryExtractStringConcatArgs(BoundExpression lowered, out ImmutableArray<BoundExpression> arguments)
         {
-            switch (lowered.Kind)
+            switch (lowered)
             {
-                case BoundKind.Call:
-                    var boundCall = (BoundCall)lowered;
+                case BoundCall boundCall:
                     var method = boundCall.Method;
                     if (method.IsStatic && method.ContainingType.SpecialType == SpecialType.System_String)
                     {
@@ -184,9 +196,7 @@ private bool TryExtractStringConcatArgs(BoundExpression lowered, out ImmutableAr
                     }
                     break;
 
-                case BoundKind.NullCoalescingOperator:
-                    var boundCoalesce = (BoundNullCoalescingOperator)lowered;
-
+                case BoundNullCoalescingOperator boundCoalesce:
                     Debug.Assert(boundCoalesce.LeftPlaceholder is null);
                     Debug.Assert(boundCoalesce.LeftConversion is null);
 
@@ -202,6 +212,65 @@ private bool TryExtractStringConcatArgs(BoundExpression lowered, out ImmutableAr
                         return true;
                     }
 
+                    break;
+
+                case BoundSequence { SideEffects.Length: 0, Value: BoundCall sequenceCall } sequence:
+                    if ((object)sequenceCall.Method == _compilation.GetSpecialTypeMember(SpecialMember.System_String__Concat_2ReadOnlySpans) ||
+                        (object)sequenceCall.Method == _compilation.GetSpecialTypeMember(SpecialMember.System_String__Concat_3ReadOnlySpans) ||
+                        (object)sequenceCall.Method == _compilation.GetSpecialTypeMember(SpecialMember.System_String__Concat_4ReadOnlySpans))
+                    {
+                        // Faced a span-based `string.Concat` call. Since we can produce such call on the previous iterations ourselves, we need to unwrap it.
+                        // The key thing is that we need not to only extract arguments, but also unwrap them from being spans and for chars also wrap them into `ToString` calls.
+                        var wrappedArgs = sequenceCall.Arguments;
+                        var unwrappedArgsBuilder = ArrayBuilder<BoundExpression>.GetInstance(capacity: wrappedArgs.Length);
+
+                        var locals = PooledHashSet<LocalSymbol>.GetInstance();
+                        locals.AddAll(sequence.Locals);
+
+                        foreach (var wrappedArg in wrappedArgs)
+                        {
+                            switch (wrappedArg)
+                            {
+                                // Check whether a call is an implicit `string -> ReadOnlySpan<char>` conversion
+                                case BoundCall { Method: var argMethod, Arguments: [var singleArgument] } when (object)argMethod == _compilation.GetSpecialTypeMember(SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar):
+                                    unwrappedArgsBuilder.Add(singleArgument);
+                                    break;
+                                // This complicated check is for a sequence, which wraps a span around single char.
+                                // The sequence needs to have this shape: `{ locals: <none>, sideEffects: temp = <original char expression>, result: new ReadOnlySpan<char>(in temp) }`
+                                case BoundSequence
+                                {
+                                    Locals.Length: 0,
+                                    SideEffects: [BoundAssignmentOperator { Right.Type.SpecialType: SpecialType.System_Char } assignment],
+                                    Value: BoundObjectCreationExpression { Constructor: var objectCreationConstructor, Arguments: [BoundLocal constructorLocal] }
+                                } when constructorLocal == assignment.Left &&
+                                       locals.Remove(constructorLocal.LocalSymbol) &&
+                                       (object)objectCreationConstructor.OriginalDefinition == _compilation.GetSpecialTypeMember(SpecialMember.System_ReadOnlySpan_T__ctor_Reference) &&
+                                       objectCreationConstructor.ContainingType.IsReadOnlySpanChar():
+                                    var wrappedExpr = ConvertConcatExprToString(assignment.Right);
+                                    unwrappedArgsBuilder.Add(wrappedExpr);
+                                    break;
+                                default:
+                                    locals.Free();
+                                    unwrappedArgsBuilder.Free();
+                                    arguments = default;
+                                    return false;
+                            }
+                        }
+
+                        if (locals.Count > 0)
+                        {
+                            // Not all locals are part of a known shape
+                            locals.Free();
+                            unwrappedArgsBuilder.Free();
+                            arguments = default;
+                            return false;
+                        }
+
+                        locals.Free();
+                        arguments = unwrappedArgsBuilder.ToImmutableAndFree();
+                        return true;
+                    }
+
                     break;
             }
 
@@ -346,6 +415,177 @@ private BoundExpression RewriteStringConcatenationManyExprs(SyntaxNode syntax, I
             return BoundCall.Synthesized(syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, method, array);
         }
 
+        private bool TryRewriteStringConcatenationWithSpanBasedConcat(SyntaxNode syntax, ArrayBuilder<BoundExpression> args, [NotNullWhen(true)] out BoundExpression? result)
+        {
+            // We should have called this only for 2, 3 or 4 arguments
+            Debug.Assert(args.Count is >= 2 and <= 4);
+
+            var preparedArgs = ArrayBuilder<BoundExpression>.GetInstance(capacity: args.Count);
+
+            var needsSpanRefParamConstructor = false;
+            var needsImplicitConversionFromStringToSpan = false;
+
+            NamedTypeSymbol? charType = null;
+
+            foreach (var arg in args)
+            {
+                Debug.Assert(arg.HasAnyErrors || arg.Type?.IsStringType() == true);
+
+                if (arg is BoundCall { ReceiverOpt: { Type: NamedTypeSymbol { SpecialType: SpecialType.System_Char } receiverCharType } receiver } potentialToStringCall &&
+                    (object)potentialToStringCall.Method.GetLeastOverriddenMethod(charType) == _compilation.GetSpecialTypeMember(SpecialMember.System_Object__ToString))
+                {
+                    needsSpanRefParamConstructor = true;
+                    charType = receiverCharType;
+                    preparedArgs.Add(receiver);
+                    continue;
+                }
+                else if (arg.ConstantValueOpt is { IsString: true, StringValue: [char c] })
+                {
+                    preparedArgs.Add(
+                        new BoundLiteral(
+                            arg.Syntax, constantValueOpt: ConstantValue.Create(c),
+                            charType ?? _compilation.GetSpecialType(SpecialType.System_Char))); // We will pull 'charType' from BoundCall, if it is bad an error has been already reported elsewhere
+                    continue;
+                }
+
+                preparedArgs.Add(arg);
+                needsImplicitConversionFromStringToSpan = true;
+            }
+
+            // It only makes sense to lower using span-based concat if at least one operand is a char.
+            // Because otherwise we will just wrap every string operand into span conversion and use span-based concat
+            // which is unnecessary IL bloat. Thus we require `needsSpanRefParamConstructor` to be true
+            if (!needsSpanRefParamConstructor)
+            {
+                preparedArgs.Free();
+                result = null;
+                return false;
+            }
+
+            // Just direct consequence of a condition above since we capture `char` type and set `needsSpanRefParamConstructor` at the same time
+            Debug.Assert(charType is not null);
+
+            var concatMember = preparedArgs.Count switch
+            {
+                2 => SpecialMember.System_String__Concat_2ReadOnlySpans,
+                3 => SpecialMember.System_String__Concat_3ReadOnlySpans,
+                4 => SpecialMember.System_String__Concat_4ReadOnlySpans,
+                _ => throw ExceptionUtilities.Unreachable(),
+            };
+
+            if (TryGetSpecialTypeMethod(syntax, concatMember, out MethodSymbol? spanConcat, isOptional: true) &&
+                tryGetNeededToSpanMembers(this, syntax, needsImplicitConversionFromStringToSpan, charType, out MethodSymbol? readOnlySpanCtorRefParamChar, out MethodSymbol? stringImplicitConversionToReadOnlySpan))
+            {
+                result = rewriteStringConcatenationWithSpanBasedConcat(
+                        syntax,
+                        _factory,
+                        spanConcat,
+                        stringImplicitConversionToReadOnlySpan,
+                        readOnlySpanCtorRefParamChar,
+                        preparedArgs.ToImmutableAndFree());
+
+                return true;
+            }
+
+            preparedArgs.Free();
+            result = null;
+            return false;
+
+            static bool tryGetNeededToSpanMembers(
+                LocalRewriter self,
+                SyntaxNode syntax,
+                bool needsImplicitConversionFromStringToSpan,
+                NamedTypeSymbol charType,
+                [NotNullWhen(true)] out MethodSymbol? readOnlySpanCtorRefParamChar,
+                out MethodSymbol? stringImplicitConversionToReadOnlySpan)
+            {
+                readOnlySpanCtorRefParamChar = null;
+                stringImplicitConversionToReadOnlySpan = null;
+
+                if (self.TryGetSpecialTypeMethod(syntax, SpecialMember.System_ReadOnlySpan_T__ctor_Reference, out MethodSymbol? readOnlySpanCtorRefParamGeneric, isOptional: true) &&
+                    readOnlySpanCtorRefParamGeneric.Parameters[0].RefKind != RefKind.Out)
+                {
+                    var readOnlySpanOfChar = readOnlySpanCtorRefParamGeneric.ContainingType.Construct(charType);
+                    readOnlySpanCtorRefParamChar = readOnlySpanCtorRefParamGeneric.AsMember(readOnlySpanOfChar);
+                }
+                else
+                {
+                    return false;
+                }
+
+                if (needsImplicitConversionFromStringToSpan)
+                {
+                    return self.TryGetSpecialTypeMethod(syntax, SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar, out stringImplicitConversionToReadOnlySpan, isOptional: true);
+                }
+
+                return true;
+            }
+
+            static BoundExpression rewriteStringConcatenationWithSpanBasedConcat(
+                SyntaxNode syntax,
+                SyntheticBoundNodeFactory factory,
+                MethodSymbol spanConcat,
+                MethodSymbol? stringImplicitConversionToReadOnlySpan,
+                MethodSymbol readOnlySpanCtorRefParamChar,
+                ImmutableArray<BoundExpression> args)
+            {
+                var preparedArgsBuilder = ArrayBuilder<BoundExpression>.GetInstance(capacity: args.Length);
+                var localsBuilder = ArrayBuilder<LocalSymbol>.GetInstance();
+
+                foreach (var arg in args)
+                {
+                    Debug.Assert(arg.Type is not null);
+
+                    if (arg.Type.SpecialType == SpecialType.System_Char)
+                    {
+                        var temp = factory.StoreToTemp(arg, out var tempAssignment);
+                        localsBuilder.Add(temp.LocalSymbol);
+
+                        Debug.Assert(readOnlySpanCtorRefParamChar.Parameters[0].RefKind != RefKind.Out);
+
+                        var wrappedChar = new BoundObjectCreationExpression(
+                            arg.Syntax,
+                            readOnlySpanCtorRefParamChar,
+                            [temp],
+                            argumentNamesOpt: default,
+                            argumentRefKindsOpt: [readOnlySpanCtorRefParamChar.Parameters[0].RefKind == RefKind.Ref ? RefKind.Ref : RefKindExtensions.StrictIn],
+                            expanded: false,
+                            argsToParamsOpt: default,
+                            defaultArguments: default,
+                            constantValueOpt: null,
+                            initializerExpressionOpt: null,
+                            type: readOnlySpanCtorRefParamChar.ContainingType);
+
+                        preparedArgsBuilder.Add(new BoundSequence(
+                            arg.Syntax,
+                            [],
+                            [tempAssignment],
+                            wrappedChar,
+                            wrappedChar.Type));
+                    }
+                    else
+                    {
+                        Debug.Assert(arg.HasAnyErrors || arg.Type.SpecialType == SpecialType.System_String);
+                        Debug.Assert(stringImplicitConversionToReadOnlySpan is not null);
+                        preparedArgsBuilder.Add(BoundCall.Synthesized(arg.Syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, stringImplicitConversionToReadOnlySpan, arg));
+                    }
+                }
+
+                var concatCall = BoundCall.Synthesized(syntax, receiverOpt: null, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, spanConcat, preparedArgsBuilder.ToImmutableAndFree());
+
+                var oldSyntax = factory.Syntax;
+                factory.Syntax = syntax;
+
+                var sequence = factory.Sequence(
+                    localsBuilder.ToImmutableAndFree(),
+                    [],
+                    concatCall);
+
+                factory.Syntax = oldSyntax;
+                return sequence;
+            }
+        }
+
         /// <summary>
         /// Most of the above optimizations are not applicable in expression trees as the operator
         /// must stay a binary operator. We cannot do much beyond constant folding which is done in binder.
@@ -381,7 +621,13 @@ private BoundExpression ConvertConcatExprToString(BoundExpression expr)
                 }
             }
 
-            Debug.Assert(expr.Type is { });
+            // If expression is of form `constantChar.ToString()` then unwrap it from a `ToString()` call so we can lower it to a constant later
+            // NOTE: We get `object.ToString()` from a compilation because we just need to compare symbols and don't need all error recovery of `TryGetSpecialTypeMethod`
+            if (expr is BoundCall { Type.SpecialType: SpecialType.System_String, Method: { Name: "ToString" } method, ReceiverOpt: { Type: NamedTypeSymbol { SpecialType: SpecialType.System_Char } charType, ConstantValueOpt.IsChar: true } } call &&
+                method.GetLeastOverriddenMember(charType) == _compilation.GetSpecialTypeMember(SpecialMember.System_Object__ToString))
+            {
+                expr = call.ReceiverOpt;
+            }
 
             // Is the expression a constant char?  If so, we can
             // simply make it a literal string instead and avoid any 
@@ -399,6 +645,8 @@ private BoundExpression ConvertConcatExprToString(BoundExpression expr)
                 }
             }
 
+            Debug.Assert(expr.Type is not null);
+
             // If it's a string already, just return it
             if (expr.Type.IsStringType())
             {
@@ -427,11 +675,16 @@ private BoundExpression ConvertConcatExprToString(BoundExpression expr)
                 }
             }
 
-            // If it's a special value type (and not a field of a MarshalByRef object), it should have its own ToString method (but we might fail to find
-            // it if object.ToString is missing). Assume that this won't be removed, and emit a direct call rather
-            // than a constrained virtual call. This keeps in the spirit of #7079, but expands the range of
-            // types to all special value types.
-            if (structToStringMethod != null && (expr.Type.SpecialType != SpecialType.None && !isFieldOfMarshalByRef(expr, _compilation)))
+            // If it's one of special value types in the given range (and not a field of a MarshalByRef object),
+            // it should have its own ToString method (but we might fail to find it if object.ToString is missing).
+            // Assume that this won't be removed, and emit a direct call rather than a constrained virtual call.
+            // This logic can probably be applied to all special types,
+            // but that would introduce a silent change every time a new special type is added,
+            // and if at some point the assumption no longer holds, this would be a bug, which might not get noticed.
+            // So to be extra safe we constrain the check to a fixed range of special types
+            if (structToStringMethod != null &&
+                expr.Type.SpecialType.CanOptimizeBehavior() &&
+                !isFieldOfMarshalByRef(expr, _compilation))
             {
                 return BoundCall.Synthesized(syntax, expr, initialBindingReceiverIsSubjectToCloning: ThreeState.Unknown, structToStringMethod);
             }
diff --git a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
index 9bfb3a387e2f3..5f5eae68a4cf5 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SpillSequenceSpiller.cs
@@ -4,7 +4,6 @@
 
 #nullable disable
 
-using System;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
@@ -469,6 +468,28 @@ private BoundExpression Spill(
                                                call.Method,
                                                ImmutableArray.Create(Spill(builder, call.Arguments[0]), Spill(builder, call.Arguments[1])));
                         }
+                        else if (call.Method == _F.Compilation.GetSpecialTypeMember(SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar))
+                        {
+                            Debug.Assert(call.Arguments.Length == 1);
+                            return call.Update([Spill(builder, call.Arguments[0])]);
+                        }
+
+                        goto default;
+
+                    case BoundKind.ObjectCreationExpression:
+                        var objectCreationExpression = (BoundObjectCreationExpression)expression;
+
+                        if (refKind == RefKind.None &&
+                            objectCreationExpression.InitializerExpressionOpt is null &&
+                            objectCreationExpression.Constructor.OriginalDefinition == _F.Compilation.GetSpecialTypeMember(SpecialMember.System_ReadOnlySpan_T__ctor_Reference))
+                        {
+                            Debug.Assert(objectCreationExpression.Arguments.Length == 1);
+                            var argRefKinds = objectCreationExpression.ArgumentRefKindsOpt;
+                            return objectCreationExpression.Update(objectCreationExpression.Constructor,
+                                                                   [Spill(builder, objectCreationExpression.Arguments[0], argRefKinds.IsDefault ? RefKind.None : argRefKinds[0])],
+                                                                   objectCreationExpression.ArgumentRefKindsOpt,
+                                                                   newInitializerExpression: null);
+                        }
 
                         goto default;
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
index 88240a3be3e5b..25bb0a30587e4 100644
--- a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
@@ -11,7 +11,6 @@
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
-using Microsoft.CodeAnalysis.Symbols;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp
@@ -440,7 +439,7 @@ private bool MightContainReferences(TypeSymbol type)
             if (type.IsReferenceType || type.TypeKind == TypeKind.TypeParameter) return true; // type parameter or reference type
             if (type.TypeKind != TypeKind.Struct) return false; // enums, etc
             if (type.SpecialType == SpecialType.System_TypedReference) return true;
-            if (type.SpecialType != SpecialType.None) return false; // int, etc
+            if (type.SpecialType.CanOptimizeBehavior()) return false; // int, etc
             if (!type.IsFromCompilation(this.CompilationState.ModuleBuilderOpt.Compilation)) return true; // perhaps from ref assembly
             foreach (var f in _emptyStructTypeCache.GetStructInstanceFields(type))
             {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
index 922bfa11143a8..dc4c06cecd0a2 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.cs
@@ -1906,12 +1906,39 @@ private MultiDictionary<string, PEFieldSymbol> CreateFields(ArrayBuilder<PEField
             {
                 if (this.SpecialType == Microsoft.CodeAnalysis.SpecialType.None)
                 {
-                    isOrdinaryStruct = true;
                     isOrdinaryEmbeddableStruct = this.ContainingAssembly.IsLinked;
                 }
-                else
-                {
-                    isOrdinaryStruct = (this.SpecialType == Microsoft.CodeAnalysis.SpecialType.System_Nullable_T);
+
+                switch (this.SpecialType)
+                {
+                    case SpecialType.System_Void:
+                    case SpecialType.System_Boolean:
+                    case SpecialType.System_Char:
+                    case SpecialType.System_Byte:
+                    case SpecialType.System_SByte:
+                    case SpecialType.System_Int16:
+                    case SpecialType.System_UInt16:
+                    case SpecialType.System_Int32:
+                    case SpecialType.System_UInt32:
+                    case SpecialType.System_Int64:
+                    case SpecialType.System_UInt64:
+                    case SpecialType.System_Single:
+                    case SpecialType.System_Double:
+                    case SpecialType.System_Decimal:
+                    case SpecialType.System_IntPtr:
+                    case SpecialType.System_UIntPtr:
+                    case SpecialType.System_DateTime:
+                    case SpecialType.System_TypedReference:
+                    case SpecialType.System_ArgIterator:
+                    case SpecialType.System_RuntimeArgumentHandle:
+                    case SpecialType.System_RuntimeFieldHandle:
+                    case SpecialType.System_RuntimeMethodHandle:
+                    case SpecialType.System_RuntimeTypeHandle:
+                        isOrdinaryStruct = false;
+                        break;
+                    default:
+                        isOrdinaryStruct = true;
+                        break;
                 }
             }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs b/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
index e3bef07119fac..0e8e38d085d93 100644
--- a/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs
@@ -7,7 +7,6 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Text;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -218,7 +217,7 @@ public static bool IsValidEnumType(this TypeSymbol type)
         {
             var underlyingType = type.GetEnumUnderlyingType();
             // SpecialType will be None if the underlying type is invalid.
-            return (underlyingType is object) && (underlyingType.SpecialType != SpecialType.None);
+            return underlyingType is not null && underlyingType.SpecialType.CanOptimizeBehavior();
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs
new file mode 100644
index 0000000000000..48efeed6dbc2b
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenSpanBasedStringConcatTests.cs
@@ -0,0 +1,5715 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen;
+
+public class CodeGenSpanBasedStringConcatTests : CSharpTestBase
+{
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_ReadOnlySpan1()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                }
+
+                static string M1(string s, char c) => s + c;
+                static string M2(string s, char c) => c + s;
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "sccs" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       21 (0x15)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       21 (0x15)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_ReadOnlySpan2()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'C';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                }
+
+                static string M1(string s, char c) => s + char.ToLowerInvariant(c);
+                static string M2(string s, char c) => char.ToLowerInvariant(c) + s;
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "sccs" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  call       "char char.ToLowerInvariant(char)"
+              IL_000c:  stloc.0
+              IL_000d:  ldloca.s   V_0
+              IL_000f:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0014:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0019:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  call       "char char.ToLowerInvariant(char)"
+              IL_0006:  stloc.0
+              IL_0007:  ldloca.s   V_0
+              IL_0009:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000e:  ldarg.0
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0019:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_ReadOnlySpan_SideEffect()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                private static int stringCounter;
+                private static int charCounterPlusOne = 1;
+
+                static void Main()
+                {
+                    Console.WriteLine(M1());
+                    Console.WriteLine(M2());
+                }
+
+                static string M1() => GetStringWithSideEffect() + GetCharWithSideEffect();
+                static string M2() => GetCharWithSideEffect() + GetStringWithSideEffect();
+
+                private static string GetStringWithSideEffect()
+                {
+                    Console.Write(stringCounter++);
+                    return "s";
+                }
+
+                private static char GetCharWithSideEffect()
+                {
+                    Console.Write(charCounterPlusOne++);
+                    return 'c';
+                }
+            }
+            """;
+
+        var expectedOutput = """
+            01sc
+            21cs
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? expectedOutput : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       29 (0x1d)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  call       "string Test.GetStringWithSideEffect()"
+              IL_0005:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000a:  call       "char Test.GetCharWithSideEffect()"
+              IL_000f:  stloc.0
+              IL_0010:  ldloca.s   V_0
+              IL_0012:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0017:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001c:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       29 (0x1d)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  call       "char Test.GetCharWithSideEffect()"
+              IL_0005:  stloc.0
+              IL_0006:  ldloca.s   V_0
+              IL_0008:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000d:  call       "string Test.GetStringWithSideEffect()"
+              IL_0012:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0017:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001c:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_ReadOnlySpan_ReferenceToSameLocation()
+    {
+        var source = """
+            using System;
+
+            var c = new C();
+            c.M();
+
+            class C
+            {
+                public char c = 'a';
+
+                public ref char GetC()
+                {
+                    c = 'b';
+                    return ref c;
+                }
+
+                public void M()
+                {
+                    Console.Write(c.ToString() + GetC());
+                }
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "ab" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("C.M", """
+            {
+              // Code size       40 (0x28)
+              .maxstack  2
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.0
+              IL_0001:  ldfld      "char C.c"
+              IL_0006:  stloc.0
+              IL_0007:  ldloca.s   V_0
+              IL_0009:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000e:  ldarg.0
+              IL_000f:  call       "ref char C.GetC()"
+              IL_0014:  ldind.u2
+              IL_0015:  stloc.1
+              IL_0016:  ldloca.s   V_1
+              IL_0018:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001d:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0022:  call       "void System.Console.Write(string)"
+              IL_0027:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_ReadOnlySpan_MutateLocal()
+    {
+        var source = """
+            using System;
+
+            var c = new C();
+            Console.WriteLine(c.M());
+
+            class C
+            {
+                public string M()
+                {
+                    var c = 'a';
+                    return c + SneakyLocalChange(ref c);
+                }
+
+                private string SneakyLocalChange(ref char local)
+                {
+                    local = 'b';
+                    return "b";
+                }
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "ab" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("C.M", """
+            {
+              // Code size       31 (0x1f)
+              .maxstack  3
+              .locals init (char V_0, //c
+                            char V_1)
+              IL_0000:  ldc.i4.s   97
+              IL_0002:  stloc.0
+              IL_0003:  ldloc.0
+              IL_0004:  stloc.1
+              IL_0005:  ldloca.s   V_1
+              IL_0007:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000c:  ldarg.0
+              IL_000d:  ldloca.s   V_0
+              IL_000f:  call       "string C.SneakyLocalChange(ref char)"
+              IL_0014:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0019:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001e:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/72232")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatTwo_ReadOnlySpan_NullConcatArgument(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var c = 'c';
+                    Console.Write(M1(c));
+                    Console.Write(M2(c));
+                }
+
+                static string M1(char c) => c + (string)null;
+                static string M2(char c) => (string)null + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "cc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        var expectedEquivalentIL = """
+            {
+              // Code size       17 (0x11)
+              .maxstack  2
+              IL_0000:  ldarga.s   V_0
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  dup
+              IL_0008:  brtrue.s   IL_0010
+              IL_000a:  pop
+              IL_000b:  ldstr      ""
+              IL_0010:  ret
+            }
+            """;
+
+        verifier.VerifyIL("Test.M1", expectedEquivalentIL);
+        verifier.VerifyIL("Test.M2", expectedEquivalentIL);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatTwo_ConstantCharToString(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    Console.Write(M1(s));
+                    Console.Write(M2(s));
+                }
+
+                static string M1(string s) => s + 'c'.ToString();
+                static string M2(string s) => 'c'.ToString() + s;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "sccs" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        // Instead of emitting this as a span-based concat of string and char we recognize "constantChar.ToString()" pattern and lower that argument to a constant string
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       12 (0xc)
+              .maxstack  2
+              IL_0000:  ldarg.0
+              IL_0001:  ldstr      "c"
+              IL_0006:  call       "string string.Concat(string, string)"
+              IL_000b:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       12 (0xc)
+              .maxstack  2
+              IL_0000:  ldstr      "c"
+              IL_0005:  ldarg.0
+              IL_0006:  call       "string string.Concat(string, string)"
+              IL_000b:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatTwo_AllConstantCharToStrings(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    Console.Write(M());
+                }
+
+                static string M() => 'a'.ToString() + 'b'.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "ab" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        // Instead of emitting this as a span-based concat of 2 chars we recognize "constantChar.ToString()" pattern and lower both arguments to a constant string
+        // which we can then fold into a single constant string and avoid concatenation entirely
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size        6 (0x6)
+              .maxstack  1
+              IL_0000:  ldstr      "ab"
+              IL_0005:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    public void ConcatTwoCharToStrings(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var c1 = 'a';
+                    var c2 = 'b';
+                    Console.Write(M(c1, c2));
+                }
+
+                static string M(char c1, char c2) => c1.ToString() + c2.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "ab" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       24 (0x18)
+              .maxstack  2
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.0
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.1
+              IL_000a:  stloc.1
+              IL_000b:  ldloca.s   V_1
+              IL_000d:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0012:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0017:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    public void ConcatTwo_ReadOnlySpan_MissingMemberForOptimization(int member)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                }
+
+                static string M1(string s, char c) => s + c;
+                static string M2(string s, char c) => c + s;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing((SpecialMember)member);
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "sccs" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       14 (0xe)
+              .maxstack  2
+              IL_0000:  ldarg.0
+              IL_0001:  ldarga.s   V_1
+              IL_0003:  call       "string char.ToString()"
+              IL_0008:  call       "string string.Concat(string, string)"
+              IL_000d:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       14 (0xe)
+              .maxstack  2
+              IL_0000:  ldarga.s   V_1
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  call       "string string.Concat(string, string)"
+              IL_000d:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_MissingObjectToString()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                }
+
+                static string M1(string s, char c) => s + c;
+                static string M2(string s, char c) => c + s;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing(SpecialMember.System_Object__ToString);
+
+        // Although we don't use object.ToString() or char.ToString() in the final codegen we still need object.ToString() during lowering.
+        // Moreover, we previously reported these errors anyway, so this is not a behavioral change
+        comp.VerifyEmitDiagnostics(
+            // (13,47): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M1(string s, char c) => s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(13, 47),
+            // (14,43): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M2(string s, char c) => c + s;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(14, 43));
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_CharDoesntOverrideObjectToString()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char { }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref readonly T reference) { }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        // No matter whether `char` directly overrides `ToString` or not, we still produce span-based concat if we can
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       21 (0x15)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(ref readonly char)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_ReadOnlySpanConstructorParameterIsOrdinaryRef()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char
+                {
+                    public override string ToString() => null;
+                }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref T reference) { }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       21 (0x15)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(ref char)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_ReadOnlySpanConstructorParameterIsOut()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char
+                {
+                    public override string ToString() => null;
+                }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(out T reference) { reference = default; }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        // Constructor of ReadOnlySpan<char> has unexpected `out` reference. Fallback to string-based concat
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       14 (0xe)
+              .maxstack  2
+              IL_0000:  ldarg.0
+              IL_0001:  ldarga.s   V_1
+              IL_0003:  call       "string char.ToString()"
+              IL_0008:  call       "string string.Concat(string, string)"
+              IL_000d:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_Await()
+    {
+        var source = """
+            using System;
+            using System.Threading.Tasks;
+
+            public class Test
+            {
+                static async Task Main()
+                {
+                    Console.Write(await M());
+                }
+
+                static async Task<string> M()
+                {
+                    return (await GetStringAsync()) + (await GetCharAsync());
+                }
+
+                static async Task<string> GetStringAsync()
+                {
+                    await Task.Yield();
+                    return "s";
+                }
+
+                static async Task<char> GetCharAsync()
+                {
+                    await Task.Yield();
+                    return 'c';
+                }
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "sc" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.<M>d__1.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", """
+            {
+              // Code size      276 (0x114)
+              .maxstack  3
+              .locals init (int V_0,
+                            string V_1,
+                            char V_2,
+                            System.Runtime.CompilerServices.TaskAwaiter<string> V_3,
+                            System.Runtime.CompilerServices.TaskAwaiter<char> V_4,
+                            System.Exception V_5)
+              IL_0000:  ldarg.0
+              IL_0001:  ldfld      "int Test.<M>d__1.<>1__state"
+              IL_0006:  stloc.0
+              .try
+              {
+                IL_0007:  ldloc.0
+                IL_0008:  brfalse.s  IL_0048
+                IL_000a:  ldloc.0
+                IL_000b:  ldc.i4.1
+                IL_000c:  beq        IL_00a7
+                IL_0011:  call       "System.Threading.Tasks.Task<string> Test.GetStringAsync()"
+                IL_0016:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<string> System.Threading.Tasks.Task<string>.GetAwaiter()"
+                IL_001b:  stloc.3
+                IL_001c:  ldloca.s   V_3
+                IL_001e:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<string>.IsCompleted.get"
+                IL_0023:  brtrue.s   IL_0064
+                IL_0025:  ldarg.0
+                IL_0026:  ldc.i4.0
+                IL_0027:  dup
+                IL_0028:  stloc.0
+                IL_0029:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_002e:  ldarg.0
+                IL_002f:  ldloc.3
+                IL_0030:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0035:  ldarg.0
+                IL_0036:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_003b:  ldloca.s   V_3
+                IL_003d:  ldarg.0
+                IL_003e:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<string>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<string>, ref Test.<M>d__1)"
+                IL_0043:  leave      IL_0113
+                IL_0048:  ldarg.0
+                IL_0049:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_004e:  stloc.3
+                IL_004f:  ldarg.0
+                IL_0050:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0055:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<string>"
+                IL_005b:  ldarg.0
+                IL_005c:  ldc.i4.m1
+                IL_005d:  dup
+                IL_005e:  stloc.0
+                IL_005f:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_0064:  ldarg.0
+                IL_0065:  ldloca.s   V_3
+                IL_0067:  call       "string System.Runtime.CompilerServices.TaskAwaiter<string>.GetResult()"
+                IL_006c:  stfld      "string Test.<M>d__1.<>7__wrap1"
+                IL_0071:  call       "System.Threading.Tasks.Task<char> Test.GetCharAsync()"
+                IL_0076:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<char> System.Threading.Tasks.Task<char>.GetAwaiter()"
+                IL_007b:  stloc.s    V_4
+                IL_007d:  ldloca.s   V_4
+                IL_007f:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<char>.IsCompleted.get"
+                IL_0084:  brtrue.s   IL_00c4
+                IL_0086:  ldarg.0
+                IL_0087:  ldc.i4.1
+                IL_0088:  dup
+                IL_0089:  stloc.0
+                IL_008a:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_008f:  ldarg.0
+                IL_0090:  ldloc.s    V_4
+                IL_0092:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_0097:  ldarg.0
+                IL_0098:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_009d:  ldloca.s   V_4
+                IL_009f:  ldarg.0
+                IL_00a0:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<char>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<char>, ref Test.<M>d__1)"
+                IL_00a5:  leave.s    IL_0113
+                IL_00a7:  ldarg.0
+                IL_00a8:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_00ad:  stloc.s    V_4
+                IL_00af:  ldarg.0
+                IL_00b0:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_00b5:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<char>"
+                IL_00bb:  ldarg.0
+                IL_00bc:  ldc.i4.m1
+                IL_00bd:  dup
+                IL_00be:  stloc.0
+                IL_00bf:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_00c4:  ldloca.s   V_4
+                IL_00c6:  call       "char System.Runtime.CompilerServices.TaskAwaiter<char>.GetResult()"
+                IL_00cb:  stloc.2
+                IL_00cc:  ldarg.0
+                IL_00cd:  ldfld      "string Test.<M>d__1.<>7__wrap1"
+                IL_00d2:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+                IL_00d7:  ldloca.s   V_2
+                IL_00d9:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+                IL_00de:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+                IL_00e3:  stloc.1
+                IL_00e4:  leave.s    IL_00ff
+              }
+              catch System.Exception
+              {
+                IL_00e6:  stloc.s    V_5
+                IL_00e8:  ldarg.0
+                IL_00e9:  ldc.i4.s   -2
+                IL_00eb:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_00f0:  ldarg.0
+                IL_00f1:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_00f6:  ldloc.s    V_5
+                IL_00f8:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.SetException(System.Exception)"
+                IL_00fd:  leave.s    IL_0113
+              }
+              IL_00ff:  ldarg.0
+              IL_0100:  ldc.i4.s   -2
+              IL_0102:  stfld      "int Test.<M>d__1.<>1__state"
+              IL_0107:  ldarg.0
+              IL_0108:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+              IL_010d:  ldloc.1
+              IL_010e:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.SetResult(string)"
+              IL_0113:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatTwo_UserDefinedReadOnlySpan()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                }
+
+                static string M1(string s, char c) => s + c;
+                static string M2(string s, char c) => c + s;
+            }
+
+            namespace System
+            {
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref readonly T reference) { }
+                }
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "sccs" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       21 (0x15)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       21 (0x15)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatThree_ReadOnlySpan1(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                }
+
+                static string M1(string s, char c) => c + s + s;
+                static string M2(string s, char c) => s + c + s;
+                static string M3(string s, char c) => s + s + c;
+                static string M4(string s, char c) => c + s + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "cssscsssccsc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.1
+              IL_000d:  stloc.0
+              IL_000e:  ldloca.s   V_0
+              IL_0010:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       30 (0x1e)
+              .maxstack  3
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.1
+              IL_0010:  stloc.1
+              IL_0011:  ldloca.s   V_1
+              IL_0013:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0018:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001d:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatThree_ReadOnlySpan2(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'C';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                }
+
+                static string M1(string s, char c) => char.ToLowerInvariant(c) + s + s;
+                static string M2(string s, char c) => s + char.ToLowerInvariant(c) + s;
+                static string M3(string s, char c) => s + s + char.ToLowerInvariant(c);
+                static string M4(string s, char c) => char.ToLowerInvariant(c) + s + char.ToLowerInvariant(c);
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "cssscsssccsc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       32 (0x20)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  call       "char char.ToLowerInvariant(char)"
+              IL_0006:  stloc.0
+              IL_0007:  ldloca.s   V_0
+              IL_0009:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000e:  ldarg.0
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  ldarg.0
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       32 (0x20)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  call       "char char.ToLowerInvariant(char)"
+              IL_000c:  stloc.0
+              IL_000d:  ldloca.s   V_0
+              IL_000f:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0014:  ldarg.0
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       32 (0x20)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.1
+              IL_000d:  call       "char char.ToLowerInvariant(char)"
+              IL_0012:  stloc.0
+              IL_0013:  ldloca.s   V_0
+              IL_0015:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001a:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       40 (0x28)
+              .maxstack  3
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  call       "char char.ToLowerInvariant(char)"
+              IL_0006:  stloc.0
+              IL_0007:  ldloca.s   V_0
+              IL_0009:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000e:  ldarg.0
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  ldarg.1
+              IL_0015:  call       "char char.ToLowerInvariant(char)"
+              IL_001a:  stloc.1
+              IL_001b:  ldloca.s   V_1
+              IL_001d:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0022:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0027:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData("(s + c) + s")]
+    [InlineData("s + (c + s)")]
+    [InlineData("string.Concat(s, c.ToString()) + s")]
+    [InlineData("s + string.Concat(c.ToString(), s)")]
+    public void ConcatThree_ReadOnlySpan_OperandGroupingAndUserInputOfStringBasedConcats(string expression)
+    {
+        var source = $$"""
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M(s, c));
+                }
+
+                static string M(string s, char c) => {{expression}};
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "scs" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatThree_ReadOnlySpan_SideEffect(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                private static int stringCounter;
+                private static int charCounterPlusOne = 1;
+
+                static void Main()
+                {
+                    Console.WriteLine(M1());
+                    Console.WriteLine(M2());
+                    Console.WriteLine(M3());
+                    Console.WriteLine(M4());
+                }
+
+                static string M1() => GetCharWithSideEffect() + GetStringWithSideEffect() + GetStringWithSideEffect();
+                static string M2() => GetStringWithSideEffect() + GetCharWithSideEffect() + GetStringWithSideEffect();
+                static string M3() => GetStringWithSideEffect() + GetStringWithSideEffect() + GetCharWithSideEffect();
+                static string M4() => GetCharWithSideEffect() + GetStringWithSideEffect() + GetCharWithSideEffect();
+
+                private static string GetStringWithSideEffect()
+                {
+                    Console.Write(stringCounter++);
+                    return "s";
+                }
+
+                private static char GetCharWithSideEffect()
+                {
+                    Console.Write(charCounterPlusOne++);
+                    return 'c';
+                }
+            }
+            """;
+
+        var expectedOutput = """
+            101css
+            223scs
+            453ssc
+            465csc
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? expectedOutput : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       39 (0x27)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  call       "char Test.GetCharWithSideEffect()"
+              IL_0005:  stloc.0
+              IL_0006:  ldloca.s   V_0
+              IL_0008:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000d:  call       "string Test.GetStringWithSideEffect()"
+              IL_0012:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0017:  call       "string Test.GetStringWithSideEffect()"
+              IL_001c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0021:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0026:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       39 (0x27)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  call       "string Test.GetStringWithSideEffect()"
+              IL_0005:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000a:  call       "char Test.GetCharWithSideEffect()"
+              IL_000f:  stloc.0
+              IL_0010:  ldloca.s   V_0
+              IL_0012:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0017:  call       "string Test.GetStringWithSideEffect()"
+              IL_001c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0021:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0026:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       39 (0x27)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  call       "string Test.GetStringWithSideEffect()"
+              IL_0005:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000a:  call       "string Test.GetStringWithSideEffect()"
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  call       "char Test.GetCharWithSideEffect()"
+              IL_0019:  stloc.0
+              IL_001a:  ldloca.s   V_0
+              IL_001c:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0021:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0026:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       42 (0x2a)
+              .maxstack  3
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  call       "char Test.GetCharWithSideEffect()"
+              IL_0005:  stloc.0
+              IL_0006:  ldloca.s   V_0
+              IL_0008:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000d:  call       "string Test.GetStringWithSideEffect()"
+              IL_0012:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0017:  call       "char Test.GetCharWithSideEffect()"
+              IL_001c:  stloc.1
+              IL_001d:  ldloca.s   V_1
+              IL_001f:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0024:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0029:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatThree_ReadOnlySpan_ReferenceToSameLocation(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            var c = new C();
+            c.M();
+
+            class C
+            {
+                public char c = 'a';
+
+                public ref char GetC()
+                {
+                    c = 'b';
+                    return ref c;
+                }
+
+                public void M()
+                {
+                    Console.Write("a" + c + GetC());
+                }
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "aab" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("C.M", """
+            {
+              // Code size       50 (0x32)
+              .maxstack  3
+              .locals init (char V_0,
+                            char V_1,
+                            char V_2)
+              IL_0000:  ldc.i4.s   97
+              IL_0002:  stloc.0
+              IL_0003:  ldloca.s   V_0
+              IL_0005:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000a:  ldarg.0
+              IL_000b:  ldfld      "char C.c"
+              IL_0010:  stloc.1
+              IL_0011:  ldloca.s   V_1
+              IL_0013:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0018:  ldarg.0
+              IL_0019:  call       "ref char C.GetC()"
+              IL_001e:  ldind.u2
+              IL_001f:  stloc.2
+              IL_0020:  ldloca.s   V_2
+              IL_0022:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0027:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_002c:  call       "void System.Console.Write(string)"
+              IL_0031:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatThree_ReadOnlySpan_MutateLocal(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            var c = new C();
+            Console.WriteLine(c.M());
+
+            class C
+            {
+                public string M()
+                {
+                    var c = 'a';
+                    return "a" + c + SneakyLocalChange(ref c);
+                }
+
+                private char SneakyLocalChange(ref char local)
+                {
+                    local = 'b';
+                    return 'b';
+                }
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "aab" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("C.M", """
+            {
+              // Code size       44 (0x2c)
+              .maxstack  4
+              .locals init (char V_0, //c
+                            char V_1,
+                            char V_2,
+                            char V_3)
+              IL_0000:  ldc.i4.s   97
+              IL_0002:  stloc.0
+              IL_0003:  ldc.i4.s   97
+              IL_0005:  stloc.1
+              IL_0006:  ldloca.s   V_1
+              IL_0008:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000d:  ldloc.0
+              IL_000e:  stloc.2
+              IL_000f:  ldloca.s   V_2
+              IL_0011:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0016:  ldarg.0
+              IL_0017:  ldloca.s   V_0
+              IL_0019:  call       "char C.SneakyLocalChange(ref char)"
+              IL_001e:  stloc.3
+              IL_001f:  ldloca.s   V_3
+              IL_0021:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0026:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_002b:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatThree_ReadOnlySpan_NullConcatArgument(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                }
+
+                static string M1(string s, char c) => (string)null + s + c;
+                static string M2(string s, char c) => s + (c + (string)null);
+                static string M3(string s, char c) => (s + c) + (string)null;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "scscsc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        var expectedEquivalentIL = """
+            {
+              // Code size       21 (0x15)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  ret
+            }
+            """;
+
+        verifier.VerifyIL("Test.M1", expectedEquivalentIL);
+        verifier.VerifyIL("Test.M2", expectedEquivalentIL);
+        verifier.VerifyIL("Test.M3", expectedEquivalentIL);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatThree_ConstantCharToString(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+            
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    Console.Write(M1(s));
+                    Console.Write(M2(s));
+                    Console.Write(M3(s));
+                    Console.Write(M4(s));
+                }
+            
+                static string M1(string s) => 'c'.ToString() + s + s;
+                static string M2(string s) => s + 'c'.ToString() + s;
+                static string M3(string s) => s + s + 'c'.ToString();
+                static string M4(string s) => 'c'.ToString() + s + 'c'.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "cssscsssccsc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        // Instead of emitting this as a span-based concat of strings and chars we recognize "constantChar.ToString()" pattern and lower that arguments to constant strings
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       13 (0xd)
+              .maxstack  3
+              IL_0000:  ldstr      "c"
+              IL_0005:  ldarg.0
+              IL_0006:  ldarg.0
+              IL_0007:  call       "string string.Concat(string, string, string)"
+              IL_000c:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       13 (0xd)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldstr      "c"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "string string.Concat(string, string, string)"
+              IL_000c:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       13 (0xd)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.0
+              IL_0002:  ldstr      "c"
+              IL_0007:  call       "string string.Concat(string, string, string)"
+              IL_000c:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       17 (0x11)
+              .maxstack  3
+              IL_0000:  ldstr      "c"
+              IL_0005:  ldarg.0
+              IL_0006:  ldstr      "c"
+              IL_000b:  call       "string string.Concat(string, string, string)"
+              IL_0010:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatThree_AllConstantCharToStrings(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    Console.Write(M());
+                }
+
+                static string M() => 'a'.ToString() + 'b'.ToString() + 'c'.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        // Instead of emitting this as a span-based concat of 3 chars we recognize "constantChar.ToString()" pattern and lower all arguments to a constant string
+        // which we can then fold into a single constant string and avoid concatenation entirely
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size        6 (0x6)
+              .maxstack  1
+              IL_0000:  ldstr      "abc"
+              IL_0005:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatThreeCharToStrings(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var c1 = 'a';
+                    var c2 = 'b';
+                    var c3 = 'c';
+                    Console.Write(M(c1, c2, c3));
+                }
+
+                static string M(char c1, char c2, char c3) => c1.ToString() + c2.ToString() + c3.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  3
+              .locals init (char V_0,
+                            char V_1,
+                            char V_2)
+              IL_0000:  ldarg.0
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.1
+              IL_000a:  stloc.1
+              IL_000b:  ldloca.s   V_1
+              IL_000d:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0012:  ldarg.2
+              IL_0013:  stloc.2
+              IL_0014:  ldloca.s   V_2
+              IL_0016:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    public void ConcatThree_ReadOnlySpan_MissingMemberForOptimization(int member)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                }
+
+                static string M1(string s, char c) => c + s + s;
+                static string M2(string s, char c) => s + c + s;
+                static string M3(string s, char c) => s + s + c;
+                static string M4(string s, char c) => c + s + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing((SpecialMember)member);
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "cssscsssccsc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       15 (0xf)
+              .maxstack  3
+              IL_0000:  ldarga.s   V_1
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarg.0
+              IL_0009:  call       "string string.Concat(string, string, string)"
+              IL_000e:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       15 (0xf)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarga.s   V_1
+              IL_0003:  call       "string char.ToString()"
+              IL_0008:  ldarg.0
+              IL_0009:  call       "string string.Concat(string, string, string)"
+              IL_000e:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       15 (0xf)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.0
+              IL_0002:  ldarga.s   V_1
+              IL_0004:  call       "string char.ToString()"
+              IL_0009:  call       "string string.Concat(string, string, string)"
+              IL_000e:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       21 (0x15)
+              .maxstack  3
+              IL_0000:  ldarga.s   V_1
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarga.s   V_1
+              IL_000a:  call       "string char.ToString()"
+              IL_000f:  call       "string string.Concat(string, string, string)"
+              IL_0014:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatThree_UserInputOfSpanBasedConcat_ConcatWithString(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var s3 = "c";
+                    Console.Write(M1(s1.AsSpan(), s2, s3));
+                    Console.Write(M2(s1.AsSpan(), s2, s3));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, string s3) => string.Concat(s1, s2.AsSpan()) + s3;
+                static string M2(ReadOnlySpan<char> s1, string s2, string s3) => s3 + string.Concat(s1, s2.AsSpan());
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abccab" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       19 (0x13)
+              .maxstack  2
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  ldarg.2
+              IL_000d:  call       "string string.Concat(string, string)"
+              IL_0012:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       19 (0x13)
+              .maxstack  3
+              IL_0000:  ldarg.2
+              IL_0001:  ldarg.0
+              IL_0002:  ldarg.1
+              IL_0003:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0008:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000d:  call       "string string.Concat(string, string)"
+              IL_0012:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatThree_UserInputOfSpanBasedConcat_ConcatWithChar()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var c = 'c';
+                    Console.Write(M1(s1.AsSpan(), s2, c));
+                    Console.Write(M2(s1.AsSpan(), s2, c));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, char c) => string.Concat(s1, s2.AsSpan()) + c;
+                static string M2(ReadOnlySpan<char> s1, string s2, char c) => c + string.Concat(s1, s2.AsSpan());
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abccab" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       32 (0x20)
+              .maxstack  2
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0011:  ldarg.2
+              IL_0012:  stloc.0
+              IL_0013:  ldloca.s   V_0
+              IL_0015:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001a:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001f:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       32 (0x20)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.2
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  ldarg.1
+              IL_000b:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0010:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001f:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    public void ConcatThree_UserInputOfSpanBasedConcat_ConcatWithChar_MissingMemberForSpanBasedConcat(int member)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var c = 'c';
+                    Console.Write(M1(s1.AsSpan(), s2, c));
+                    Console.Write(M2(s1.AsSpan(), s2, c));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, char c) => string.Concat(s1, s2.AsSpan()) + c;
+                static string M2(ReadOnlySpan<char> s1, string s2, char c) => c + string.Concat(s1, s2.AsSpan());
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing((SpecialMember)member);
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abccab" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       25 (0x19)
+              .maxstack  2
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  ldarga.s   V_2
+              IL_000e:  call       "string char.ToString()"
+              IL_0013:  call       "string string.Concat(string, string)"
+              IL_0018:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       25 (0x19)
+              .maxstack  3
+              IL_0000:  ldarga.s   V_2
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarg.1
+              IL_0009:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_000e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0013:  call       "string string.Concat(string, string)"
+              IL_0018:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatThree_MissingObjectToString()
+    {
+        var source = """
+            using System;
+            
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                }
+            
+                static string M1(string s, char c) => c + s + s;
+                static string M2(string s, char c) => s + c + s;
+                static string M3(string s, char c) => s + s + c;
+                static string M4(string s, char c) => c + s + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing(SpecialMember.System_Object__ToString);
+
+        // Although we don't use object.ToString() or char.ToString() in the final codegen we still need object.ToString() during lowering.
+        // Moreover, we previously reported these errors anyway, so this is not a behavioral change
+        comp.VerifyEmitDiagnostics(
+            // (15,43): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M1(string s, char c) => c + s + s;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(15, 43),
+            // (16,47): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M2(string s, char c) => s + c + s;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(16, 47),
+            // (17,51): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M3(string s, char c) => s + s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(17, 51),
+            // (18,43): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M4(string s, char c) => c + s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(18, 43),
+            // (18,51): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M4(string s, char c) => c + s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(18, 51));
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatThree_CharDoesntOverrideObjectToString()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(string str0, string str1, string str2) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char { }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref readonly T reference) { }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c + s;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        // No matter whether `char` directly overrides `ToString` or not, we still produce span-based concat if we can
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(ref readonly char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatThree_ReadOnlySpanConstructorParameterIsOrdinaryRef()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(string str0, string str1, string str2) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char
+                {
+                    public override string ToString() => null;
+                }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref T reference) { }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c + s;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(ref char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatThree_ReadOnlySpanConstructorParameterIsOut()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(string str0, string str1, string str2) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char
+                {
+                    public override string ToString() => null;
+                }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(out T reference) { reference = default; }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c + s;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        // Constructor of ReadOnlySpan<char> has unexpected `out` reference. Fallback to string-based concat
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       15 (0xf)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarga.s   V_1
+              IL_0003:  call       "string char.ToString()"
+              IL_0008:  ldarg.0
+              IL_0009:  call       "string string.Concat(string, string, string)"
+              IL_000e:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatThree_Await()
+    {
+        var source = """
+            using System;
+            using System.Threading.Tasks;
+
+            public class Test
+            {
+                static async Task Main()
+                {
+                    Console.Write(await M());
+                }
+
+                static async Task<string> M()
+                {
+                    return (await GetStringAsync()) + (await GetCharAsync()) + (await GetStringAsync());
+                }
+
+                static async Task<string> GetStringAsync()
+                {
+                    await Task.Yield();
+                    return "s";
+                }
+
+                static async Task<char> GetCharAsync()
+                {
+                    await Task.Yield();
+                    return 'c';
+                }
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "scs" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.<M>d__1.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", """
+            {
+              // Code size      398 (0x18e)
+              .maxstack  3
+              .locals init (int V_0,
+                            string V_1,
+                            char V_2,
+                            string V_3,
+                            System.Runtime.CompilerServices.TaskAwaiter<string> V_4,
+                            System.Runtime.CompilerServices.TaskAwaiter<char> V_5,
+                            System.Exception V_6)
+              IL_0000:  ldarg.0
+              IL_0001:  ldfld      "int Test.<M>d__1.<>1__state"
+              IL_0006:  stloc.0
+              .try
+              {
+                IL_0007:  ldloc.0
+                IL_0008:  switch    (
+                    IL_0052,
+                    IL_00b5,
+                    IL_0117)
+                IL_0019:  call       "System.Threading.Tasks.Task<string> Test.GetStringAsync()"
+                IL_001e:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<string> System.Threading.Tasks.Task<string>.GetAwaiter()"
+                IL_0023:  stloc.s    V_4
+                IL_0025:  ldloca.s   V_4
+                IL_0027:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<string>.IsCompleted.get"
+                IL_002c:  brtrue.s   IL_006f
+                IL_002e:  ldarg.0
+                IL_002f:  ldc.i4.0
+                IL_0030:  dup
+                IL_0031:  stloc.0
+                IL_0032:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_0037:  ldarg.0
+                IL_0038:  ldloc.s    V_4
+                IL_003a:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_003f:  ldarg.0
+                IL_0040:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_0045:  ldloca.s   V_4
+                IL_0047:  ldarg.0
+                IL_0048:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<string>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<string>, ref Test.<M>d__1)"
+                IL_004d:  leave      IL_018d
+                IL_0052:  ldarg.0
+                IL_0053:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0058:  stloc.s    V_4
+                IL_005a:  ldarg.0
+                IL_005b:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0060:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<string>"
+                IL_0066:  ldarg.0
+                IL_0067:  ldc.i4.m1
+                IL_0068:  dup
+                IL_0069:  stloc.0
+                IL_006a:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_006f:  ldarg.0
+                IL_0070:  ldloca.s   V_4
+                IL_0072:  call       "string System.Runtime.CompilerServices.TaskAwaiter<string>.GetResult()"
+                IL_0077:  stfld      "string Test.<M>d__1.<>7__wrap2"
+                IL_007c:  call       "System.Threading.Tasks.Task<char> Test.GetCharAsync()"
+                IL_0081:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<char> System.Threading.Tasks.Task<char>.GetAwaiter()"
+                IL_0086:  stloc.s    V_5
+                IL_0088:  ldloca.s   V_5
+                IL_008a:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<char>.IsCompleted.get"
+                IL_008f:  brtrue.s   IL_00d2
+                IL_0091:  ldarg.0
+                IL_0092:  ldc.i4.1
+                IL_0093:  dup
+                IL_0094:  stloc.0
+                IL_0095:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_009a:  ldarg.0
+                IL_009b:  ldloc.s    V_5
+                IL_009d:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_00a2:  ldarg.0
+                IL_00a3:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_00a8:  ldloca.s   V_5
+                IL_00aa:  ldarg.0
+                IL_00ab:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<char>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<char>, ref Test.<M>d__1)"
+                IL_00b0:  leave      IL_018d
+                IL_00b5:  ldarg.0
+                IL_00b6:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_00bb:  stloc.s    V_5
+                IL_00bd:  ldarg.0
+                IL_00be:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_00c3:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<char>"
+                IL_00c9:  ldarg.0
+                IL_00ca:  ldc.i4.m1
+                IL_00cb:  dup
+                IL_00cc:  stloc.0
+                IL_00cd:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_00d2:  ldloca.s   V_5
+                IL_00d4:  call       "char System.Runtime.CompilerServices.TaskAwaiter<char>.GetResult()"
+                IL_00d9:  stloc.2
+                IL_00da:  ldarg.0
+                IL_00db:  ldloc.2
+                IL_00dc:  stfld      "char Test.<M>d__1.<>7__wrap1"
+                IL_00e1:  call       "System.Threading.Tasks.Task<string> Test.GetStringAsync()"
+                IL_00e6:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<string> System.Threading.Tasks.Task<string>.GetAwaiter()"
+                IL_00eb:  stloc.s    V_4
+                IL_00ed:  ldloca.s   V_4
+                IL_00ef:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<string>.IsCompleted.get"
+                IL_00f4:  brtrue.s   IL_0134
+                IL_00f6:  ldarg.0
+                IL_00f7:  ldc.i4.2
+                IL_00f8:  dup
+                IL_00f9:  stloc.0
+                IL_00fa:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_00ff:  ldarg.0
+                IL_0100:  ldloc.s    V_4
+                IL_0102:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0107:  ldarg.0
+                IL_0108:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_010d:  ldloca.s   V_4
+                IL_010f:  ldarg.0
+                IL_0110:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<string>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<string>, ref Test.<M>d__1)"
+                IL_0115:  leave.s    IL_018d
+                IL_0117:  ldarg.0
+                IL_0118:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_011d:  stloc.s    V_4
+                IL_011f:  ldarg.0
+                IL_0120:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0125:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<string>"
+                IL_012b:  ldarg.0
+                IL_012c:  ldc.i4.m1
+                IL_012d:  dup
+                IL_012e:  stloc.0
+                IL_012f:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_0134:  ldloca.s   V_4
+                IL_0136:  call       "string System.Runtime.CompilerServices.TaskAwaiter<string>.GetResult()"
+                IL_013b:  stloc.3
+                IL_013c:  ldarg.0
+                IL_013d:  ldfld      "string Test.<M>d__1.<>7__wrap2"
+                IL_0142:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+                IL_0147:  ldarg.0
+                IL_0148:  ldflda     "char Test.<M>d__1.<>7__wrap1"
+                IL_014d:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+                IL_0152:  ldloc.3
+                IL_0153:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+                IL_0158:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+                IL_015d:  stloc.1
+                IL_015e:  leave.s    IL_0179
+              }
+              catch System.Exception
+              {
+                IL_0160:  stloc.s    V_6
+                IL_0162:  ldarg.0
+                IL_0163:  ldc.i4.s   -2
+                IL_0165:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_016a:  ldarg.0
+                IL_016b:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_0170:  ldloc.s    V_6
+                IL_0172:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.SetException(System.Exception)"
+                IL_0177:  leave.s    IL_018d
+              }
+              IL_0179:  ldarg.0
+              IL_017a:  ldc.i4.s   -2
+              IL_017c:  stfld      "int Test.<M>d__1.<>1__state"
+              IL_0181:  ldarg.0
+              IL_0182:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+              IL_0187:  ldloc.1
+              IL_0188:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.SetResult(string)"
+              IL_018d:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatThree_UserDefinedReadOnlySpan()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                }
+
+                static string M1(string s, char c) => c + s + s;
+                static string M2(string s, char c) => s + c + s;
+                static string M3(string s, char c) => s + s + c;
+                static string M4(string s, char c) => c + s + c;
+            }
+
+            namespace System
+            {
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref readonly T reference) { }
+                }
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "cssscsssccsc" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M3", """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.1
+              IL_000d:  stloc.0
+              IL_000e:  ldloca.s   V_0
+              IL_0010:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M4", """
+            {
+              // Code size       30 (0x1e)
+              .maxstack  3
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.1
+              IL_0010:  stloc.1
+              IL_0011:  ldloca.s   V_1
+              IL_0013:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0018:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001d:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFour_ReadOnlySpan1(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                    Console.Write(M5(s, c));
+                    Console.Write(M6(s, c));
+                    Console.Write(M7(s, c));
+                }
+
+                static string M1(string s, char c) => c + s + s + s;
+                static string M2(string s, char c) => s + c + s + s;
+                static string M3(string s, char c) => s + s + c + s;
+                static string M4(string s, char c) => s + s + s + c;
+                static string M5(string s, char c) => c + s + c + s;
+                static string M6(string s, char c) => s + c + s + c;
+                static string M7(string s, char c) => c + s + s + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "csssscsssscssssccscsscsccssc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.1
+              IL_000d:  stloc.0
+              IL_000e:  ldloca.s   V_0
+              IL_0010:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.0
+              IL_000d:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0012:  ldarg.1
+              IL_0013:  stloc.0
+              IL_0014:  ldloca.s   V_0
+              IL_0016:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M5", """
+            {
+              // Code size       36 (0x24)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.1
+              IL_0010:  stloc.1
+              IL_0011:  ldloca.s   V_1
+              IL_0013:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0018:  ldarg.0
+              IL_0019:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0023:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M6", """
+            {
+              // Code size       36 (0x24)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.1
+              IL_0016:  stloc.1
+              IL_0017:  ldloca.s   V_1
+              IL_0019:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0023:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M7", """
+            {
+              // Code size       36 (0x24)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.1
+              IL_0016:  stloc.1
+              IL_0017:  ldloca.s   V_1
+              IL_0019:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0023:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFour_ReadOnlySpan2(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'C';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                    Console.Write(M5(s, c));
+                    Console.Write(M6(s, c));
+                    Console.Write(M7(s, c));
+                }
+
+                static string M1(string s, char c) => char.ToLowerInvariant(c) + s + s + s;
+                static string M2(string s, char c) => s + char.ToLowerInvariant(c) + s + s;
+                static string M3(string s, char c) => s + s + char.ToLowerInvariant(c) + s;
+                static string M4(string s, char c) => s + s + s + char.ToLowerInvariant(c);
+                static string M5(string s, char c) => char.ToLowerInvariant(c) + s + char.ToLowerInvariant(c) + s;
+                static string M6(string s, char c) => s + char.ToLowerInvariant(c) + s + char.ToLowerInvariant(c);
+                static string M7(string s, char c) => char.ToLowerInvariant(c) + s + s + char.ToLowerInvariant(c);
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "csssscsssscssssccscsscsccssc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  call       "char char.ToLowerInvariant(char)"
+              IL_0006:  stloc.0
+              IL_0007:  ldloca.s   V_0
+              IL_0009:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000e:  ldarg.0
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  ldarg.0
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  ldarg.0
+              IL_001b:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  call       "char char.ToLowerInvariant(char)"
+              IL_000c:  stloc.0
+              IL_000d:  ldloca.s   V_0
+              IL_000f:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0014:  ldarg.0
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  ldarg.0
+              IL_001b:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.1
+              IL_000d:  call       "char char.ToLowerInvariant(char)"
+              IL_0012:  stloc.0
+              IL_0013:  ldloca.s   V_0
+              IL_0015:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001a:  ldarg.0
+              IL_001b:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.0
+              IL_000d:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0012:  ldarg.1
+              IL_0013:  call       "char char.ToLowerInvariant(char)"
+              IL_0018:  stloc.0
+              IL_0019:  ldloca.s   V_0
+              IL_001b:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M5", """
+            {
+              // Code size       46 (0x2e)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  call       "char char.ToLowerInvariant(char)"
+              IL_0006:  stloc.0
+              IL_0007:  ldloca.s   V_0
+              IL_0009:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000e:  ldarg.0
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  ldarg.1
+              IL_0015:  call       "char char.ToLowerInvariant(char)"
+              IL_001a:  stloc.1
+              IL_001b:  ldloca.s   V_1
+              IL_001d:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0022:  ldarg.0
+              IL_0023:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0028:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_002d:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M6", """
+            {
+              // Code size       46 (0x2e)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  call       "char char.ToLowerInvariant(char)"
+              IL_000c:  stloc.0
+              IL_000d:  ldloca.s   V_0
+              IL_000f:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0014:  ldarg.0
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  ldarg.1
+              IL_001b:  call       "char char.ToLowerInvariant(char)"
+              IL_0020:  stloc.1
+              IL_0021:  ldloca.s   V_1
+              IL_0023:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0028:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_002d:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M7", """
+            {
+              // Code size       46 (0x2e)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  call       "char char.ToLowerInvariant(char)"
+              IL_0006:  stloc.0
+              IL_0007:  ldloca.s   V_0
+              IL_0009:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000e:  ldarg.0
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  ldarg.0
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  ldarg.1
+              IL_001b:  call       "char char.ToLowerInvariant(char)"
+              IL_0020:  stloc.1
+              IL_0021:  ldloca.s   V_1
+              IL_0023:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0028:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_002d:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData("(s + c) + s + s")]
+    [InlineData("s + (c + s) + s")]
+    [InlineData("s + c + (s + s)")]
+    [InlineData("(s + c + s) + s")]
+    [InlineData("s + (c + s + s)")]
+    [InlineData("(s + c) + (s + s)")]
+    [InlineData("string.Concat(s, c.ToString()) + s + s")]
+    [InlineData("s + string.Concat(c.ToString(), s) + s")]
+    [InlineData("s + c + string.Concat(s, s)")]
+    [InlineData("string.Concat(s, c.ToString(), s) + s")]
+    [InlineData("s + string.Concat(c.ToString(), s, s)")]
+    [InlineData("string.Concat(s, c.ToString()) + string.Concat(s, s)")]
+    public void ConcatFour_ReadOnlySpan_OperandGroupingAndUserInputOfStringBasedConcats(string expression)
+    {
+        var source = $$"""
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M(s, c));
+                }
+
+                static string M(string s, char c) => {{expression}};
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "scss" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFour_ReadOnlySpan_SideEffect(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                private static int stringCounter;
+                private static int charCounterPlusOne = 1;
+
+                static void Main()
+                {
+                    Console.WriteLine(M1());
+                    Console.WriteLine(M2());
+                    Console.WriteLine(M3());
+                    Console.WriteLine(M4());
+                    Console.WriteLine(M5());
+                    Console.WriteLine(M6());
+                    Console.WriteLine(M7());
+                }
+
+                static string M1() => GetCharWithSideEffect() + GetStringWithSideEffect() + GetStringWithSideEffect() + GetStringWithSideEffect();
+                static string M2() => GetStringWithSideEffect() + GetCharWithSideEffect() + GetStringWithSideEffect() + GetStringWithSideEffect();
+                static string M3() => GetStringWithSideEffect() + GetStringWithSideEffect() + GetCharWithSideEffect() + GetStringWithSideEffect();
+                static string M4() => GetStringWithSideEffect() + GetStringWithSideEffect() + GetStringWithSideEffect() + GetCharWithSideEffect();
+                static string M5() => GetCharWithSideEffect() + GetStringWithSideEffect() + GetCharWithSideEffect() + GetStringWithSideEffect();
+                static string M6() => GetStringWithSideEffect() + GetCharWithSideEffect() + GetStringWithSideEffect() + GetCharWithSideEffect();
+                static string M7() => GetCharWithSideEffect() + GetStringWithSideEffect() + GetStringWithSideEffect() + GetCharWithSideEffect();
+
+                private static string GetStringWithSideEffect()
+                {
+                    Console.Write(stringCounter++);
+                    return "s";
+                }
+
+                private static char GetCharWithSideEffect()
+                {
+                    Console.Write(charCounterPlusOne++);
+                    return 'c';
+                }
+            }
+            """;
+
+        var expectedOutput = """
+            1012csss
+            3245scss
+            6738sscs
+            910114sssc
+            512613cscs
+            147158scsc
+            9161710cssc
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? expectedOutput : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       49 (0x31)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  call       "char Test.GetCharWithSideEffect()"
+              IL_0005:  stloc.0
+              IL_0006:  ldloca.s   V_0
+              IL_0008:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000d:  call       "string Test.GetStringWithSideEffect()"
+              IL_0012:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0017:  call       "string Test.GetStringWithSideEffect()"
+              IL_001c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0021:  call       "string Test.GetStringWithSideEffect()"
+              IL_0026:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_002b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0030:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       49 (0x31)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  call       "string Test.GetStringWithSideEffect()"
+              IL_0005:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000a:  call       "char Test.GetCharWithSideEffect()"
+              IL_000f:  stloc.0
+              IL_0010:  ldloca.s   V_0
+              IL_0012:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0017:  call       "string Test.GetStringWithSideEffect()"
+              IL_001c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0021:  call       "string Test.GetStringWithSideEffect()"
+              IL_0026:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_002b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0030:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       49 (0x31)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  call       "string Test.GetStringWithSideEffect()"
+              IL_0005:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000a:  call       "string Test.GetStringWithSideEffect()"
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  call       "char Test.GetCharWithSideEffect()"
+              IL_0019:  stloc.0
+              IL_001a:  ldloca.s   V_0
+              IL_001c:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0021:  call       "string Test.GetStringWithSideEffect()"
+              IL_0026:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_002b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0030:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       49 (0x31)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  call       "string Test.GetStringWithSideEffect()"
+              IL_0005:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000a:  call       "string Test.GetStringWithSideEffect()"
+              IL_000f:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0014:  call       "string Test.GetStringWithSideEffect()"
+              IL_0019:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001e:  call       "char Test.GetCharWithSideEffect()"
+              IL_0023:  stloc.0
+              IL_0024:  ldloca.s   V_0
+              IL_0026:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_002b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0030:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M5", """
+            {
+              // Code size       52 (0x34)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  call       "char Test.GetCharWithSideEffect()"
+              IL_0005:  stloc.0
+              IL_0006:  ldloca.s   V_0
+              IL_0008:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000d:  call       "string Test.GetStringWithSideEffect()"
+              IL_0012:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0017:  call       "char Test.GetCharWithSideEffect()"
+              IL_001c:  stloc.1
+              IL_001d:  ldloca.s   V_1
+              IL_001f:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0024:  call       "string Test.GetStringWithSideEffect()"
+              IL_0029:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_002e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0033:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M6", """
+            {
+              // Code size       52 (0x34)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  call       "string Test.GetStringWithSideEffect()"
+              IL_0005:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000a:  call       "char Test.GetCharWithSideEffect()"
+              IL_000f:  stloc.0
+              IL_0010:  ldloca.s   V_0
+              IL_0012:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0017:  call       "string Test.GetStringWithSideEffect()"
+              IL_001c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0021:  call       "char Test.GetCharWithSideEffect()"
+              IL_0026:  stloc.1
+              IL_0027:  ldloca.s   V_1
+              IL_0029:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_002e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0033:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M7", """
+            {
+              // Code size       52 (0x34)
+              .maxstack  4
+              .locals init (char V_0,
+                          char V_1)
+              IL_0000:  call       "char Test.GetCharWithSideEffect()"
+              IL_0005:  stloc.0
+              IL_0006:  ldloca.s   V_0
+              IL_0008:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000d:  call       "string Test.GetStringWithSideEffect()"
+              IL_0012:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0017:  call       "string Test.GetStringWithSideEffect()"
+              IL_001c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0021:  call       "char Test.GetCharWithSideEffect()"
+              IL_0026:  stloc.1
+              IL_0027:  ldloca.s   V_1
+              IL_0029:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_002e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0033:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFour_ReadOnlySpan_ReferenceToSameLocation(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            var c = new C();
+            c.M();
+
+            class C
+            {
+                public char c = 'a';
+
+                public ref char GetC() => ref c;
+
+                public ref char GetC2()
+                {
+                    c = 'b';
+                    return ref c;
+                }
+
+                public void M()
+                {
+                    Console.Write("a" + c + GetC() + GetC2());
+                }
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "aaab" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("C.M", """
+            {
+              // Code size       65 (0x41)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1,
+                            char V_2,
+                            char V_3)
+              IL_0000:  ldc.i4.s   97
+              IL_0002:  stloc.0
+              IL_0003:  ldloca.s   V_0
+              IL_0005:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000a:  ldarg.0
+              IL_000b:  ldfld      "char C.c"
+              IL_0010:  stloc.1
+              IL_0011:  ldloca.s   V_1
+              IL_0013:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0018:  ldarg.0
+              IL_0019:  call       "ref char C.GetC()"
+              IL_001e:  ldind.u2
+              IL_001f:  stloc.2
+              IL_0020:  ldloca.s   V_2
+              IL_0022:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0027:  ldarg.0
+              IL_0028:  call       "ref char C.GetC2()"
+              IL_002d:  ldind.u2
+              IL_002e:  stloc.3
+              IL_002f:  ldloca.s   V_3
+              IL_0031:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0036:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_003b:  call       "void System.Console.Write(string)"
+              IL_0040:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFour_ReadOnlySpan_MutateLocal(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            var c = new C();
+            Console.WriteLine(c.M());
+
+            class C
+            {
+                public string M()
+                {
+                    var c1 = 'a';
+                    var c2 = 'a';
+                    return c1 + SneakyLocalChange(ref c1) + c2 + SneakyLocalChange(ref c2);
+                }
+
+                private string SneakyLocalChange(ref char local)
+                {
+                    local = 'b';
+                    return "b";
+                }
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abab" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("C.M", """
+            {
+              // Code size       56 (0x38)
+              .maxstack  5
+              .locals init (char V_0, //c1
+                            char V_1, //c2
+                            char V_2,
+                            char V_3)
+              IL_0000:  ldc.i4.s   97
+              IL_0002:  stloc.0
+              IL_0003:  ldc.i4.s   97
+              IL_0005:  stloc.1
+              IL_0006:  ldloc.0
+              IL_0007:  stloc.2
+              IL_0008:  ldloca.s   V_2
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  ldloca.s   V_0
+              IL_0012:  call       "string C.SneakyLocalChange(ref char)"
+              IL_0017:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001c:  ldloc.1
+              IL_001d:  stloc.3
+              IL_001e:  ldloca.s   V_3
+              IL_0020:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0025:  ldarg.0
+              IL_0026:  ldloca.s   V_1
+              IL_0028:  call       "string C.SneakyLocalChange(ref char)"
+              IL_002d:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0032:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0037:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_4ReadOnlySpans)]
+    public void ConcatFour_ReadOnlySpan_NullConcatArgument(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                    Console.Write(M5(s, c));
+                    Console.Write(M6(s, c));
+                }
+
+                static string M1(string s, char c) => (string)null + s + c + s;
+                static string M2(string s, char c) => s + (string)null + c + s;
+                static string M3(string s, char c) => s + ((string)null + c) + s;
+                static string M4(string s, char c) => s + c + (string)null + s;
+                static string M5(string s, char c) => s + (c + (string)null) + s;
+                static string M6(string s, char c) => s + c + s + (string)null;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "scsscsscsscsscsscs" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        var expectedEquivalentIL = """
+            {
+              // Code size       27 (0x1b)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  ret
+            }
+            """;
+
+        verifier.VerifyIL("Test.M1", expectedEquivalentIL);
+        verifier.VerifyIL("Test.M2", expectedEquivalentIL);
+        verifier.VerifyIL("Test.M3", expectedEquivalentIL);
+        verifier.VerifyIL("Test.M4", expectedEquivalentIL);
+        verifier.VerifyIL("Test.M5", expectedEquivalentIL);
+        verifier.VerifyIL("Test.M6", expectedEquivalentIL);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_4ReadOnlySpans)]
+    public void ConcatFour_ConstantCharToString(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+            
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    Console.Write(M1(s));
+                    Console.Write(M2(s));
+                    Console.Write(M3(s));
+                    Console.Write(M4(s));
+                    Console.Write(M5(s));
+                    Console.Write(M6(s));
+                    Console.Write(M7(s));
+                }
+            
+                static string M1(string s) => 'c'.ToString() + s + s + s;
+                static string M2(string s) => s + 'c'.ToString() + s + s;
+                static string M3(string s) => s + s + 'c'.ToString() + s;
+                static string M4(string s) => s + s + s + 'c'.ToString();
+                static string M5(string s) => 'c'.ToString() + s + 'c'.ToString() + s;
+                static string M6(string s) => s + 'c'.ToString() + s + 'c'.ToString();
+                static string M7(string s) => 'c'.ToString() + s + s + 'c'.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "csssscsssscssssccscsscsccssc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        // Instead of emitting this as a span-based concat of strings and chars we recognize "constantChar.ToString()" pattern and lower that arguments to constant strings
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       14 (0xe)
+              .maxstack  4
+              IL_0000:  ldstr      "c"
+              IL_0005:  ldarg.0
+              IL_0006:  ldarg.0
+              IL_0007:  ldarg.0
+              IL_0008:  call       "string string.Concat(string, string, string, string)"
+              IL_000d:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       14 (0xe)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldstr      "c"
+              IL_0006:  ldarg.0
+              IL_0007:  ldarg.0
+              IL_0008:  call       "string string.Concat(string, string, string, string)"
+              IL_000d:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       14 (0xe)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.0
+              IL_0002:  ldstr      "c"
+              IL_0007:  ldarg.0
+              IL_0008:  call       "string string.Concat(string, string, string, string)"
+              IL_000d:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       14 (0xe)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.0
+              IL_0002:  ldarg.0
+              IL_0003:  ldstr      "c"
+              IL_0008:  call       "string string.Concat(string, string, string, string)"
+              IL_000d:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M5", """
+            {
+              // Code size       18 (0x12)
+              .maxstack  4
+              IL_0000:  ldstr      "c"
+              IL_0005:  ldarg.0
+              IL_0006:  ldstr      "c"
+              IL_000b:  ldarg.0
+              IL_000c:  call       "string string.Concat(string, string, string, string)"
+              IL_0011:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M6", """
+            {
+              // Code size       18 (0x12)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldstr      "c"
+              IL_0006:  ldarg.0
+              IL_0007:  ldstr      "c"
+              IL_000c:  call       "string string.Concat(string, string, string, string)"
+              IL_0011:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M7", """
+            {
+              // Code size       18 (0x12)
+              .maxstack  4
+              IL_0000:  ldstr      "c"
+              IL_0005:  ldarg.0
+              IL_0006:  ldarg.0
+              IL_0007:  ldstr      "c"
+              IL_000c:  call       "string string.Concat(string, string, string, string)"
+              IL_0011:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_4ReadOnlySpans)]
+    public void ConcatFour_AllConstantCharToStrings(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    Console.Write(M());
+                }
+
+                static string M() => 'a'.ToString() + 'b'.ToString() + 'c'.ToString() + 'd'.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcd" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        // Instead of emitting this as a span-based concat of 4 chars we recognize "constantChar.ToString()" pattern and lower all arguments to a constant string
+        // which we can then fold into a single constant string and avoid concatenation entirely
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size        6 (0x6)
+              .maxstack  1
+              IL_0000:  ldstr      "abcd"
+              IL_0005:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFourCharToStrings(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var c1 = 'a';
+                    var c2 = 'b';
+                    var c3 = 'c';
+                    var c4 = 'd';
+                    Console.Write(M(c1, c2, c3, c4));
+                }
+
+                static string M(char c1, char c2, char c3, char c4) => c1.ToString() + c2.ToString() + c3.ToString() + c4.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcd" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       42 (0x2a)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1,
+                            char V_2,
+                            char V_3)
+              IL_0000:  ldarg.0
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.1
+              IL_000a:  stloc.1
+              IL_000b:  ldloca.s   V_1
+              IL_000d:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0012:  ldarg.2
+              IL_0013:  stloc.2
+              IL_0014:  ldloca.s   V_2
+              IL_0016:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001b:  ldarg.3
+              IL_001c:  stloc.3
+              IL_001d:  ldloca.s   V_3
+              IL_001f:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0024:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0029:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData((int)SpecialMember.System_String__Concat_4ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    public void ConcatFour_ReadOnlySpan_MissingMemberForOptimization(int member)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                    Console.Write(M5(s, c));
+                    Console.Write(M6(s, c));
+                    Console.Write(M7(s, c));
+                }
+
+                static string M1(string s, char c) => c + s + s + s;
+                static string M2(string s, char c) => s + c + s + s;
+                static string M3(string s, char c) => s + s + c + s;
+                static string M4(string s, char c) => s + s + s + c;
+                static string M5(string s, char c) => c + s + c + s;
+                static string M6(string s, char c) => s + c + s + c;
+                static string M7(string s, char c) => c + s + s + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing((SpecialMember)member);
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "csssscsssscssssccscsscsccssc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       16 (0x10)
+              .maxstack  4
+              IL_0000:  ldarga.s   V_1
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarg.0
+              IL_0009:  ldarg.0
+              IL_000a:  call       "string string.Concat(string, string, string, string)"
+              IL_000f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       16 (0x10)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldarga.s   V_1
+              IL_0003:  call       "string char.ToString()"
+              IL_0008:  ldarg.0
+              IL_0009:  ldarg.0
+              IL_000a:  call       "string string.Concat(string, string, string, string)"
+              IL_000f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       16 (0x10)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.0
+              IL_0002:  ldarga.s   V_1
+              IL_0004:  call       "string char.ToString()"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "string string.Concat(string, string, string, string)"
+              IL_000f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       16 (0x10)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.0
+              IL_0002:  ldarg.0
+              IL_0003:  ldarga.s   V_1
+              IL_0005:  call       "string char.ToString()"
+              IL_000a:  call       "string string.Concat(string, string, string, string)"
+              IL_000f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M5", """
+            {
+              // Code size       22 (0x16)
+              .maxstack  4
+              IL_0000:  ldarga.s   V_1
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarga.s   V_1
+              IL_000a:  call       "string char.ToString()"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "string string.Concat(string, string, string, string)"
+              IL_0015:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M6", """
+            {
+              // Code size       22 (0x16)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldarga.s   V_1
+              IL_0003:  call       "string char.ToString()"
+              IL_0008:  ldarg.0
+              IL_0009:  ldarga.s   V_1
+              IL_000b:  call       "string char.ToString()"
+              IL_0010:  call       "string string.Concat(string, string, string, string)"
+              IL_0015:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M7", """
+            {
+              // Code size       22 (0x16)
+              .maxstack  4
+              IL_0000:  ldarga.s   V_1
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarg.0
+              IL_0009:  ldarga.s   V_1
+              IL_000b:  call       "string char.ToString()"
+              IL_0010:  call       "string string.Concat(string, string, string, string)"
+              IL_0015:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFour_UserInputOfSpanBasedConcatOf2_ConcatWithString(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var s3 = "c";
+                    Console.Write(M1(s1.AsSpan(), s2, s3));
+                    Console.Write(M2(s1.AsSpan(), s2, s3));
+                    Console.Write(M3(s1.AsSpan(), s2, s3));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, string s3) => string.Concat(s1, s2.AsSpan()) + s3 + s3;
+                static string M2(ReadOnlySpan<char> s1, string s2, string s3) => s3 + s3 + string.Concat(s1, s2.AsSpan());
+                static string M3(ReadOnlySpan<char> s1, string s2, string s3) => s3 + string.Concat(s1, s2.AsSpan()) + s3;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abccccabcabc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       20 (0x14)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  ldarg.2
+              IL_000d:  ldarg.2
+              IL_000e:  call       "string string.Concat(string, string, string)"
+              IL_0013:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       20 (0x14)
+              .maxstack  4
+              IL_0000:  ldarg.2
+              IL_0001:  ldarg.2
+              IL_0002:  ldarg.0
+              IL_0003:  ldarg.1
+              IL_0004:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0009:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000e:  call       "string string.Concat(string, string, string)"
+              IL_0013:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       20 (0x14)
+              .maxstack  3
+              IL_0000:  ldarg.2
+              IL_0001:  ldarg.0
+              IL_0002:  ldarg.1
+              IL_0003:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0008:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000d:  ldarg.2
+              IL_000e:  call       "string string.Concat(string, string, string)"
+              IL_0013:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_UserInputOfSpanBasedConcatOf2_ConcatWithChar()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var c = 'c';
+                    Console.Write(M1(s1.AsSpan(), s2, c));
+                    Console.Write(M2(s1.AsSpan(), s2, c));
+                    Console.Write(M3(s1.AsSpan(), s2, c));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, char c) => string.Concat(s1, s2.AsSpan()) + c + c;
+                static string M2(ReadOnlySpan<char> s1, string s2, char c) => c.ToString() + c + string.Concat(s1, s2.AsSpan());
+                static string M3(ReadOnlySpan<char> s1, string s2, char c) => c + string.Concat(s1, s2.AsSpan()) + c;
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abccccabcabc" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       41 (0x29)
+              .maxstack  3
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0011:  ldarg.2
+              IL_0012:  stloc.0
+              IL_0013:  ldloca.s   V_0
+              IL_0015:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001a:  ldarg.2
+              IL_001b:  stloc.1
+              IL_001c:  ldloca.s   V_1
+              IL_001e:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0023:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0028:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       41 (0x29)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.2
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.2
+              IL_000a:  stloc.1
+              IL_000b:  ldloca.s   V_1
+              IL_000d:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0012:  ldarg.0
+              IL_0013:  ldarg.1
+              IL_0014:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0019:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001e:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0023:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0028:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M3", """
+            {
+              // Code size       41 (0x29)
+              .maxstack  3
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.2
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  ldarg.1
+              IL_000b:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0010:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  ldarg.2
+              IL_001b:  stloc.1
+              IL_001c:  ldloca.s   V_1
+              IL_001e:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0023:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0028:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_UserInputOfSpanBasedConcatOf2_ConcatWithStringAndChar()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var s3 = "c";
+                    var c = 'd';
+                    Console.Write(M1(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M2(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M3(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M4(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M5(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M6(s1.AsSpan(), s2, s3, c));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, string s3, char c) => string.Concat(s1, s2.AsSpan()) + s3 + c;
+                static string M2(ReadOnlySpan<char> s1, string s2, string s3, char c) => string.Concat(s1, s2.AsSpan()) + c + s3;
+                static string M3(ReadOnlySpan<char> s1, string s2, string s3, char c) => s3 + c + string.Concat(s1, s2.AsSpan());
+                static string M4(ReadOnlySpan<char> s1, string s2, string s3, char c) => c + s3 + string.Concat(s1, s2.AsSpan());
+                static string M5(ReadOnlySpan<char> s1, string s2, string s3, char c) => s3 + string.Concat(s1, s2.AsSpan()) + c;
+                static string M6(ReadOnlySpan<char> s1, string s2, string s3, char c) => c + string.Concat(s1, s2.AsSpan()) + s3;
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcdabdccdabdcabcabddabc" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0011:  ldarg.2
+              IL_0012:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0017:  ldarg.3
+              IL_0018:  stloc.0
+              IL_0019:  ldloca.s   V_0
+              IL_001b:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0011:  ldarg.3
+              IL_0012:  stloc.0
+              IL_0013:  ldloca.s   V_0
+              IL_0015:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001a:  ldarg.2
+              IL_001b:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M3", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.2
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.3
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  ldarg.1
+              IL_0011:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0016:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001b:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M4", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.3
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.2
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.0
+              IL_0010:  ldarg.1
+              IL_0011:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0016:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001b:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M5", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.2
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  ldarg.1
+              IL_0008:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_000d:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0012:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0017:  ldarg.3
+              IL_0018:  stloc.0
+              IL_0019:  ldloca.s   V_0
+              IL_001b:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M6", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.3
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  ldarg.1
+              IL_000b:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0010:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0015:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001a:  ldarg.2
+              IL_001b:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0020:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0025:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    public void ConcatFour_TwoUserInputsOfSpanBasedConcatOf2(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var s3 = "c";
+                    var s4 = "d";
+                    Console.Write(M(s1.AsSpan(), s2.AsSpan(), s3.AsSpan(), s4.AsSpan()));
+                }
+
+                static string M(ReadOnlySpan<char> s1, ReadOnlySpan<char> s2, ReadOnlySpan<char> s3, ReadOnlySpan<char> s4) => string.Concat(s1, s2) + string.Concat(s3, s4);
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcd" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       20 (0x14)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0007:  ldarg.2
+              IL_0008:  ldarg.3
+              IL_0009:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000e:  call       "string string.Concat(string, string)"
+              IL_0013:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatFour_UserInputOfSpanBasedConcatOf3_ConcatWithString(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var s3 = "c";
+                    var s4 = "d";
+                    Console.Write(M1(s1.AsSpan(), s2, s3.AsSpan(), s4));
+                    Console.Write(M2(s1.AsSpan(), s2, s3.AsSpan(), s4));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, ReadOnlySpan<char> s3, string s4) => string.Concat(s1, s2.AsSpan(), s3) + s4;
+                static string M2(ReadOnlySpan<char> s1, string s2, ReadOnlySpan<char> s3, string s4) => s4 + string.Concat(s1, s2.AsSpan(), s3);
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcddabc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       20 (0x14)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  ldarg.2
+              IL_0008:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000d:  ldarg.3
+              IL_000e:  call       "string string.Concat(string, string)"
+              IL_0013:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       20 (0x14)
+              .maxstack  4
+              IL_0000:  ldarg.3
+              IL_0001:  ldarg.0
+              IL_0002:  ldarg.1
+              IL_0003:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0008:  ldarg.2
+              IL_0009:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000e:  call       "string string.Concat(string, string)"
+              IL_0013:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_UserInputOfSpanBasedConcatOf3_ConcatWithChar()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var s3 = "c";
+                    var c = 'd';
+                    Console.Write(M1(s1.AsSpan(), s2, s3.AsSpan(), c));
+                    Console.Write(M2(s1.AsSpan(), s2, s3.AsSpan(), c));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, ReadOnlySpan<char> s3, char c) => string.Concat(s1, s2.AsSpan(), s3) + c;
+                static string M2(ReadOnlySpan<char> s1, string s2, ReadOnlySpan<char> s3, char c) => c + string.Concat(s1, s2.AsSpan(), s3);
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcddabc" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  3
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  ldarg.2
+              IL_0008:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000d:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0012:  ldarg.3
+              IL_0013:  stloc.0
+              IL_0014:  ldloca.s   V_0
+              IL_0016:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.3
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  ldarg.1
+              IL_000b:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0010:  ldarg.2
+              IL_0011:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFour_UserInputOfSpanBasedConcatOf2_ConcatWithChar_MissingMemberForSpanBasedConcatConcat(int member)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var c = 'c';
+                    Console.Write(M1(s1.AsSpan(), s2, c));
+                    Console.Write(M2(s1.AsSpan(), s2, c));
+                    Console.Write(M3(s1.AsSpan(), s2, c));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, char c) => string.Concat(s1, s2.AsSpan()) + c + c;
+                static string M2(ReadOnlySpan<char> s1, string s2, char c) => c.ToString() + c + string.Concat(s1, s2.AsSpan());
+                static string M3(ReadOnlySpan<char> s1, string s2, char c) => c + string.Concat(s1, s2.AsSpan()) + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing((SpecialMember)member);
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abccccabcabc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       32 (0x20)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  ldarga.s   V_2
+              IL_000e:  call       "string char.ToString()"
+              IL_0013:  ldarga.s   V_2
+              IL_0015:  call       "string char.ToString()"
+              IL_001a:  call       "string string.Concat(string, string, string)"
+              IL_001f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       32 (0x20)
+              .maxstack  4
+              IL_0000:  ldarga.s   V_2
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarga.s   V_2
+              IL_0009:  call       "string char.ToString()"
+              IL_000e:  ldarg.0
+              IL_000f:  ldarg.1
+              IL_0010:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0015:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_001a:  call       "string string.Concat(string, string, string)"
+              IL_001f:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       32 (0x20)
+              .maxstack  3
+              IL_0000:  ldarga.s   V_2
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarg.1
+              IL_0009:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_000e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0013:  ldarga.s   V_2
+              IL_0015:  call       "string char.ToString()"
+              IL_001a:  call       "string string.Concat(string, string, string)"
+              IL_001f:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    public void ConcatFour_UserInputOfSpanBasedConcatOf2_ConcatWithStringAndChar_MissingMemberForSpanBasedConcat(int member)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var s3 = "c";
+                    var c = 'd';
+                    Console.Write(M1(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M2(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M3(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M4(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M5(s1.AsSpan(), s2, s3, c));
+                    Console.Write(M6(s1.AsSpan(), s2, s3, c));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, string s3, char c) => string.Concat(s1, s2.AsSpan()) + s3 + c;
+                static string M2(ReadOnlySpan<char> s1, string s2, string s3, char c) => string.Concat(s1, s2.AsSpan()) + c + s3;
+                static string M3(ReadOnlySpan<char> s1, string s2, string s3, char c) => s3 + c + string.Concat(s1, s2.AsSpan());
+                static string M4(ReadOnlySpan<char> s1, string s2, string s3, char c) => c + s3 + string.Concat(s1, s2.AsSpan());
+                static string M5(ReadOnlySpan<char> s1, string s2, string s3, char c) => s3 + string.Concat(s1, s2.AsSpan()) + c;
+                static string M6(ReadOnlySpan<char> s1, string s2, string s3, char c) => c + string.Concat(s1, s2.AsSpan()) + s3;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing((SpecialMember)member);
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcdabdccdabdcabcabddabc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  ldarg.2
+              IL_000d:  ldarga.s   V_3
+              IL_000f:  call       "string char.ToString()"
+              IL_0014:  call       "string string.Concat(string, string, string)"
+              IL_0019:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000c:  ldarga.s   V_3
+              IL_000e:  call       "string char.ToString()"
+              IL_0013:  ldarg.2
+              IL_0014:  call       "string string.Concat(string, string, string)"
+              IL_0019:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M3", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  4
+              IL_0000:  ldarg.2
+              IL_0001:  ldarga.s   V_3
+              IL_0003:  call       "string char.ToString()"
+              IL_0008:  ldarg.0
+              IL_0009:  ldarg.1
+              IL_000a:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  call       "string string.Concat(string, string, string)"
+              IL_0019:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M4", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  4
+              IL_0000:  ldarga.s   V_3
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.2
+              IL_0008:  ldarg.0
+              IL_0009:  ldarg.1
+              IL_000a:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  call       "string string.Concat(string, string, string)"
+              IL_0019:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M5", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  3
+              IL_0000:  ldarg.2
+              IL_0001:  ldarg.0
+              IL_0002:  ldarg.1
+              IL_0003:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0008:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000d:  ldarga.s   V_3
+              IL_000f:  call       "string char.ToString()"
+              IL_0014:  call       "string string.Concat(string, string, string)"
+              IL_0019:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M6", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  3
+              IL_0000:  ldarga.s   V_3
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarg.1
+              IL_0009:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_000e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0013:  ldarg.2
+              IL_0014:  call       "string string.Concat(string, string, string)"
+              IL_0019:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    public void ConcatFour_UserInputOfSpanBasedConcatOf3_ConcatWithChar_MissingMemberForSpanBasedConcat(int member)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s1 = "a";
+                    var s2 = "b";
+                    var s3 = "c";
+                    var c = 'd';
+                    Console.Write(M1(s1.AsSpan(), s2, s3.AsSpan(), c));
+                    Console.Write(M2(s1.AsSpan(), s2, s3.AsSpan(), c));
+                }
+
+                static string M1(ReadOnlySpan<char> s1, string s2, ReadOnlySpan<char> s3, char c) => string.Concat(s1, s2.AsSpan(), s3) + c;
+                static string M2(ReadOnlySpan<char> s1, string s2, ReadOnlySpan<char> s3, char c) => c + string.Concat(s1, s2.AsSpan(), s3);
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing((SpecialMember)member);
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcddabc" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M1", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  3
+              IL_0000:  ldarg.0
+              IL_0001:  ldarg.1
+              IL_0002:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_0007:  ldarg.2
+              IL_0008:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_000d:  ldarga.s   V_3
+              IL_000f:  call       "string char.ToString()"
+              IL_0014:  call       "string string.Concat(string, string)"
+              IL_0019:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.M2", """
+            {
+              // Code size       26 (0x1a)
+              .maxstack  4
+              IL_0000:  ldarga.s   V_3
+              IL_0002:  call       "string char.ToString()"
+              IL_0007:  ldarg.0
+              IL_0008:  ldarg.1
+              IL_0009:  call       "System.ReadOnlySpan<char> System.MemoryExtensions.AsSpan(string)"
+              IL_000e:  ldarg.2
+              IL_000f:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0014:  call       "string string.Concat(string, string)"
+              IL_0019:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_MissingObjectToString()
+    {
+        var source = """
+            using System;
+            
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                    Console.Write(M5(s, c));
+                    Console.Write(M6(s, c));
+                    Console.Write(M7(s, c));
+                }
+            
+                static string M1(string s, char c) => c + s + s + s;
+                static string M2(string s, char c) => s + c + s + s;
+                static string M3(string s, char c) => s + s + c + s;
+                static string M4(string s, char c) => s + s + s + c;
+                static string M5(string s, char c) => c + s + c + s;
+                static string M6(string s, char c) => s + c + s + c;
+                static string M7(string s, char c) => c + s + s + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+        comp.MakeMemberMissing(SpecialMember.System_Object__ToString);
+
+        // Although we don't use object.ToString() or char.ToString() in the final codegen we still need object.ToString() during lowering.
+        // Moreover, we previously reported these errors anyway, so this is not a behavioral change
+        comp.VerifyEmitDiagnostics(
+            // (18,43): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M1(string s, char c) => c + s + s + s;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(18, 43),
+            // (19,47): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M2(string s, char c) => s + c + s + s;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(19, 47),
+            // (20,51): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M3(string s, char c) => s + s + c + s;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(20, 51),
+            // (21,55): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M4(string s, char c) => s + s + s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(21, 55),
+            // (22,43): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M5(string s, char c) => c + s + c + s;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(22, 43),
+            // (22,51): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M5(string s, char c) => c + s + c + s;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(22, 51),
+            // (23,47): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M6(string s, char c) => s + c + s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(23, 47),
+            // (23,55): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M6(string s, char c) => s + c + s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(23, 55),
+            // (24,43): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M7(string s, char c) => c + s + s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(24, 43),
+            // (24,55): error CS0656: Missing compiler required member 'System.Object.ToString'
+            //     static string M7(string s, char c) => c + s + s + c;
+            Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "c").WithArguments("System.Object", "ToString").WithLocation(24, 55));
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_CharDoesntOverrideObjectToString()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(string str0, string str1, string str2) => null;
+                    public static string Concat(string str0, string str1, string str2, string str3) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char { }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref readonly T reference) { }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c + s + s;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        // No matter whether `char` directly overrides `ToString` or not, we still produce span-based concat if we can
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(ref readonly char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_ReadOnlySpanConstructorParameterIsOrdinaryRef()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(string str0, string str1, string str2) => null;
+                    public static string Concat(string str0, string str1, string str2, string str3) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char
+                {
+                    public override string ToString() => null;
+                }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref T reference) { }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c + s + s;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(ref char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_ReadOnlySpanConstructorParameterIsOut()
+    {
+        var corlib_cs = """
+            namespace System
+            {
+                public class Object
+                {
+                    public virtual string ToString() => null;
+                }
+                public class String
+                {
+                    public static string Concat(string str0, string str1) => null;
+                    public static string Concat(string str0, string str1, string str2) => null;
+                    public static string Concat(string str0, string str1, string str2, string str3) => null;
+                    public static string Concat(ReadOnlySpan<char> str0, ReadOnlySpan<char> str1, ReadOnlySpan<char> str2, ReadOnlySpan<char> str3) => null;
+                    public static implicit operator ReadOnlySpan<char>(string value) => default;
+                }
+                public class ValueType { }
+                public struct Char
+                {
+                    public override string ToString() => null;
+                }
+                public struct Void { }
+                public struct Int32 { }
+                public struct Byte { }
+                public struct Boolean { }
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(out T reference) { reference = default; }
+                }
+                public class Enum : ValueType { }
+                public class Attribute { }
+                public enum AttributeTargets { }
+                public class AttributeUsageAttribute : Attribute
+                {
+                    public AttributeUsageAttribute(AttributeTargets validOn) { }
+
+                    public bool AllowMultiple { get { return default; } set { } }
+                    public bool Inherited { get { return default; } set { } }
+                }
+            }
+            """;
+
+        var corlib = CreateEmptyCompilation(corlib_cs).EmitToImageReference();
+
+        var source = """
+            public class Test
+            {
+                static string M(string s, char c) => s + c + s + s;
+            }
+            """;
+
+        var comp = CreateEmptyCompilation(source, [corlib]);
+        comp.VerifyDiagnostics();
+
+        var verifier = CompileAndVerify(compilation: comp, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+        verifier.VerifyDiagnostics();
+
+        // Constructor of ReadOnlySpan<char> has unexpected `out` reference. Fallback to string-based concat
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       16 (0x10)
+              .maxstack  4
+              IL_0000:  ldarg.0
+              IL_0001:  ldarga.s   V_1
+              IL_0003:  call       "string char.ToString()"
+              IL_0008:  ldarg.0
+              IL_0009:  ldarg.0
+              IL_000a:  call       "string string.Concat(string, string, string, string)"
+              IL_000f:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_Await()
+    {
+        var source = """
+            using System;
+            using System.Threading.Tasks;
+
+            public class Test
+            {
+                static async Task Main()
+                {
+                    Console.Write(await M());
+                }
+
+                static async Task<string> M()
+                {
+                    return (await GetStringAsync()) + (await GetCharAsync()) + (await GetCharAsync()) + (await GetStringAsync());
+                }
+
+                static async Task<string> GetStringAsync()
+                {
+                    await Task.Yield();
+                    return "s";
+                }
+
+                static async Task<char> GetCharAsync()
+                {
+                    await Task.Yield();
+                    return 'c';
+                }
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "sccs" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.<M>d__1.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", """
+            {
+              // Code size      519 (0x207)
+              .maxstack  4
+              .locals init (int V_0,
+                            string V_1,
+                            char V_2,
+                            char V_3,
+                            string V_4,
+                            System.Runtime.CompilerServices.TaskAwaiter<string> V_5,
+                            System.Runtime.CompilerServices.TaskAwaiter<char> V_6,
+                            System.Exception V_7)
+              IL_0000:  ldarg.0
+              IL_0001:  ldfld      "int Test.<M>d__1.<>1__state"
+              IL_0006:  stloc.0
+              .try
+              {
+                IL_0007:  ldloc.0
+                IL_0008:  switch    (
+                    IL_0056,
+                    IL_00b9,
+                    IL_011e,
+                    IL_0183)
+                IL_001d:  call       "System.Threading.Tasks.Task<string> Test.GetStringAsync()"
+                IL_0022:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<string> System.Threading.Tasks.Task<string>.GetAwaiter()"
+                IL_0027:  stloc.s    V_5
+                IL_0029:  ldloca.s   V_5
+                IL_002b:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<string>.IsCompleted.get"
+                IL_0030:  brtrue.s   IL_0073
+                IL_0032:  ldarg.0
+                IL_0033:  ldc.i4.0
+                IL_0034:  dup
+                IL_0035:  stloc.0
+                IL_0036:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_003b:  ldarg.0
+                IL_003c:  ldloc.s    V_5
+                IL_003e:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0043:  ldarg.0
+                IL_0044:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_0049:  ldloca.s   V_5
+                IL_004b:  ldarg.0
+                IL_004c:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<string>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<string>, ref Test.<M>d__1)"
+                IL_0051:  leave      IL_0206
+                IL_0056:  ldarg.0
+                IL_0057:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_005c:  stloc.s    V_5
+                IL_005e:  ldarg.0
+                IL_005f:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0064:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<string>"
+                IL_006a:  ldarg.0
+                IL_006b:  ldc.i4.m1
+                IL_006c:  dup
+                IL_006d:  stloc.0
+                IL_006e:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_0073:  ldarg.0
+                IL_0074:  ldloca.s   V_5
+                IL_0076:  call       "string System.Runtime.CompilerServices.TaskAwaiter<string>.GetResult()"
+                IL_007b:  stfld      "string Test.<M>d__1.<>7__wrap3"
+                IL_0080:  call       "System.Threading.Tasks.Task<char> Test.GetCharAsync()"
+                IL_0085:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<char> System.Threading.Tasks.Task<char>.GetAwaiter()"
+                IL_008a:  stloc.s    V_6
+                IL_008c:  ldloca.s   V_6
+                IL_008e:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<char>.IsCompleted.get"
+                IL_0093:  brtrue.s   IL_00d6
+                IL_0095:  ldarg.0
+                IL_0096:  ldc.i4.1
+                IL_0097:  dup
+                IL_0098:  stloc.0
+                IL_0099:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_009e:  ldarg.0
+                IL_009f:  ldloc.s    V_6
+                IL_00a1:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_00a6:  ldarg.0
+                IL_00a7:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_00ac:  ldloca.s   V_6
+                IL_00ae:  ldarg.0
+                IL_00af:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<char>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<char>, ref Test.<M>d__1)"
+                IL_00b4:  leave      IL_0206
+                IL_00b9:  ldarg.0
+                IL_00ba:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_00bf:  stloc.s    V_6
+                IL_00c1:  ldarg.0
+                IL_00c2:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_00c7:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<char>"
+                IL_00cd:  ldarg.0
+                IL_00ce:  ldc.i4.m1
+                IL_00cf:  dup
+                IL_00d0:  stloc.0
+                IL_00d1:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_00d6:  ldloca.s   V_6
+                IL_00d8:  call       "char System.Runtime.CompilerServices.TaskAwaiter<char>.GetResult()"
+                IL_00dd:  stloc.2
+                IL_00de:  ldarg.0
+                IL_00df:  ldloc.2
+                IL_00e0:  stfld      "char Test.<M>d__1.<>7__wrap1"
+                IL_00e5:  call       "System.Threading.Tasks.Task<char> Test.GetCharAsync()"
+                IL_00ea:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<char> System.Threading.Tasks.Task<char>.GetAwaiter()"
+                IL_00ef:  stloc.s    V_6
+                IL_00f1:  ldloca.s   V_6
+                IL_00f3:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<char>.IsCompleted.get"
+                IL_00f8:  brtrue.s   IL_013b
+                IL_00fa:  ldarg.0
+                IL_00fb:  ldc.i4.2
+                IL_00fc:  dup
+                IL_00fd:  stloc.0
+                IL_00fe:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_0103:  ldarg.0
+                IL_0104:  ldloc.s    V_6
+                IL_0106:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_010b:  ldarg.0
+                IL_010c:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_0111:  ldloca.s   V_6
+                IL_0113:  ldarg.0
+                IL_0114:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<char>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<char>, ref Test.<M>d__1)"
+                IL_0119:  leave      IL_0206
+                IL_011e:  ldarg.0
+                IL_011f:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_0124:  stloc.s    V_6
+                IL_0126:  ldarg.0
+                IL_0127:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<char> Test.<M>d__1.<>u__2"
+                IL_012c:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<char>"
+                IL_0132:  ldarg.0
+                IL_0133:  ldc.i4.m1
+                IL_0134:  dup
+                IL_0135:  stloc.0
+                IL_0136:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_013b:  ldloca.s   V_6
+                IL_013d:  call       "char System.Runtime.CompilerServices.TaskAwaiter<char>.GetResult()"
+                IL_0142:  stloc.3
+                IL_0143:  ldarg.0
+                IL_0144:  ldloc.3
+                IL_0145:  stfld      "char Test.<M>d__1.<>7__wrap2"
+                IL_014a:  call       "System.Threading.Tasks.Task<string> Test.GetStringAsync()"
+                IL_014f:  callvirt   "System.Runtime.CompilerServices.TaskAwaiter<string> System.Threading.Tasks.Task<string>.GetAwaiter()"
+                IL_0154:  stloc.s    V_5
+                IL_0156:  ldloca.s   V_5
+                IL_0158:  call       "bool System.Runtime.CompilerServices.TaskAwaiter<string>.IsCompleted.get"
+                IL_015d:  brtrue.s   IL_01a0
+                IL_015f:  ldarg.0
+                IL_0160:  ldc.i4.3
+                IL_0161:  dup
+                IL_0162:  stloc.0
+                IL_0163:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_0168:  ldarg.0
+                IL_0169:  ldloc.s    V_5
+                IL_016b:  stfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0170:  ldarg.0
+                IL_0171:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_0176:  ldloca.s   V_5
+                IL_0178:  ldarg.0
+                IL_0179:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<string>, Test.<M>d__1>(ref System.Runtime.CompilerServices.TaskAwaiter<string>, ref Test.<M>d__1)"
+                IL_017e:  leave      IL_0206
+                IL_0183:  ldarg.0
+                IL_0184:  ldfld      "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0189:  stloc.s    V_5
+                IL_018b:  ldarg.0
+                IL_018c:  ldflda     "System.Runtime.CompilerServices.TaskAwaiter<string> Test.<M>d__1.<>u__1"
+                IL_0191:  initobj    "System.Runtime.CompilerServices.TaskAwaiter<string>"
+                IL_0197:  ldarg.0
+                IL_0198:  ldc.i4.m1
+                IL_0199:  dup
+                IL_019a:  stloc.0
+                IL_019b:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_01a0:  ldloca.s   V_5
+                IL_01a2:  call       "string System.Runtime.CompilerServices.TaskAwaiter<string>.GetResult()"
+                IL_01a7:  stloc.s    V_4
+                IL_01a9:  ldarg.0
+                IL_01aa:  ldfld      "string Test.<M>d__1.<>7__wrap3"
+                IL_01af:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+                IL_01b4:  ldarg.0
+                IL_01b5:  ldflda     "char Test.<M>d__1.<>7__wrap1"
+                IL_01ba:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+                IL_01bf:  ldarg.0
+                IL_01c0:  ldflda     "char Test.<M>d__1.<>7__wrap2"
+                IL_01c5:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+                IL_01ca:  ldloc.s    V_4
+                IL_01cc:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+                IL_01d1:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+                IL_01d6:  stloc.1
+                IL_01d7:  leave.s    IL_01f2
+              }
+              catch System.Exception
+              {
+                IL_01d9:  stloc.s    V_7
+                IL_01db:  ldarg.0
+                IL_01dc:  ldc.i4.s   -2
+                IL_01de:  stfld      "int Test.<M>d__1.<>1__state"
+                IL_01e3:  ldarg.0
+                IL_01e4:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+                IL_01e9:  ldloc.s    V_7
+                IL_01eb:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.SetException(System.Exception)"
+                IL_01f0:  leave.s    IL_0206
+              }
+              IL_01f2:  ldarg.0
+              IL_01f3:  ldc.i4.s   -2
+              IL_01f5:  stfld      "int Test.<M>d__1.<>1__state"
+              IL_01fa:  ldarg.0
+              IL_01fb:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string> Test.<M>d__1.<>t__builder"
+              IL_0200:  ldloc.1
+              IL_0201:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<string>.SetResult(string)"
+              IL_0206:  ret
+            }
+            """);
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    public void ConcatFour_UserDefinedReadOnlySpan()
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M1(s, c));
+                    Console.Write(M2(s, c));
+                    Console.Write(M3(s, c));
+                    Console.Write(M4(s, c));
+                    Console.Write(M5(s, c));
+                    Console.Write(M6(s, c));
+                    Console.Write(M7(s, c));
+                }
+
+                static string M1(string s, char c) => c + s + s + s;
+                static string M2(string s, char c) => s + c + s + s;
+                static string M3(string s, char c) => s + s + c + s;
+                static string M4(string s, char c) => s + s + s + c;
+                static string M5(string s, char c) => c + s + c + s;
+                static string M6(string s, char c) => s + c + s + c;
+                static string M7(string s, char c) => c + s + s + c;
+            }
+
+            namespace System
+            {
+                public struct ReadOnlySpan<T>
+                {
+                    public ReadOnlySpan(ref readonly T reference) { }
+                }
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "csssscsssscssssccscsscsccssc" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M1", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M2", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M3", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.1
+              IL_000d:  stloc.0
+              IL_000e:  ldloca.s   V_0
+              IL_0010:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0015:  ldarg.0
+              IL_0016:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M4", """
+            {
+              // Code size       33 (0x21)
+              .maxstack  4
+              .locals init (char V_0)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.0
+              IL_0007:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000c:  ldarg.0
+              IL_000d:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0012:  ldarg.1
+              IL_0013:  stloc.0
+              IL_0014:  ldloca.s   V_0
+              IL_0016:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001b:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0020:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M5", """
+            {
+              // Code size       36 (0x24)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.1
+              IL_0010:  stloc.1
+              IL_0011:  ldloca.s   V_1
+              IL_0013:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0018:  ldarg.0
+              IL_0019:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_001e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0023:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M6", """
+            {
+              // Code size       36 (0x24)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.0
+              IL_0001:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0006:  ldarg.1
+              IL_0007:  stloc.0
+              IL_0008:  ldloca.s   V_0
+              IL_000a:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.1
+              IL_0016:  stloc.1
+              IL_0017:  ldloca.s   V_1
+              IL_0019:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0023:  ret
+            }
+            """);
+        comp.VerifyIL("Test.M7", """
+            {
+              // Code size       36 (0x24)
+              .maxstack  4
+              .locals init (char V_0,
+                            char V_1)
+              IL_0000:  ldarg.1
+              IL_0001:  stloc.0
+              IL_0002:  ldloca.s   V_0
+              IL_0004:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_0009:  ldarg.0
+              IL_000a:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_000f:  ldarg.0
+              IL_0010:  call       "System.ReadOnlySpan<char> string.op_Implicit(string)"
+              IL_0015:  ldarg.1
+              IL_0016:  stloc.1
+              IL_0017:  ldloca.s   V_1
+              IL_0019:  newobj     "System.ReadOnlySpan<char>..ctor(in char)"
+              IL_001e:  call       "string string.Concat(System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>, System.ReadOnlySpan<char>)"
+              IL_0023:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_4ReadOnlySpans)]
+    public void ConcatFive_Char(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(CharInFirstFourArgs(s, c));
+                    Console.Write(CharAfterFirstFourArgs(s, c));
+                }
+
+                static string CharInFirstFourArgs(string s, char c) => s + c + s + s + s;
+                static string CharAfterFirstFourArgs(string s, char c) => s + s + s + s + c;
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "scsssssssc" : null, verify: ExecutionConditionUtil.IsCoreClr ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+
+        // When lengths of inputs are low it is actually more optimal to first concat 4 operands with span-based concat and then concat that result with the remaining operand.
+        // However when inputs become large enough cost of allocating a params array becomes lower than cost of creating an intermediate string.
+        // + code size for using params array is less than code size from intermediate concat approach, especially when the amount of operands is high.
+        // So in the end we always prefer overload with params array when there are 5+ operands
+        verifier.VerifyIL("Test.CharInFirstFourArgs", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              IL_0000:  ldc.i4.5
+              IL_0001:  newarr     "string"
+              IL_0006:  dup
+              IL_0007:  ldc.i4.0
+              IL_0008:  ldarg.0
+              IL_0009:  stelem.ref
+              IL_000a:  dup
+              IL_000b:  ldc.i4.1
+              IL_000c:  ldarga.s   V_1
+              IL_000e:  call       "string char.ToString()"
+              IL_0013:  stelem.ref
+              IL_0014:  dup
+              IL_0015:  ldc.i4.2
+              IL_0016:  ldarg.0
+              IL_0017:  stelem.ref
+              IL_0018:  dup
+              IL_0019:  ldc.i4.3
+              IL_001a:  ldarg.0
+              IL_001b:  stelem.ref
+              IL_001c:  dup
+              IL_001d:  ldc.i4.4
+              IL_001e:  ldarg.0
+              IL_001f:  stelem.ref
+              IL_0020:  call       "string string.Concat(params string[])"
+              IL_0025:  ret
+            }
+            """);
+        verifier.VerifyIL("Test.CharAfterFirstFourArgs", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              IL_0000:  ldc.i4.5
+              IL_0001:  newarr     "string"
+              IL_0006:  dup
+              IL_0007:  ldc.i4.0
+              IL_0008:  ldarg.0
+              IL_0009:  stelem.ref
+              IL_000a:  dup
+              IL_000b:  ldc.i4.1
+              IL_000c:  ldarg.0
+              IL_000d:  stelem.ref
+              IL_000e:  dup
+              IL_000f:  ldc.i4.2
+              IL_0010:  ldarg.0
+              IL_0011:  stelem.ref
+              IL_0012:  dup
+              IL_0013:  ldc.i4.3
+              IL_0014:  ldarg.0
+              IL_0015:  stelem.ref
+              IL_0016:  dup
+              IL_0017:  ldc.i4.4
+              IL_0018:  ldarga.s   V_1
+              IL_001a:  call       "string char.ToString()"
+              IL_001f:  stelem.ref
+              IL_0020:  call       "string string.Concat(params string[])"
+              IL_0025:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData("(s + s) + c + s + s")]
+    [InlineData("s + (s + c) + s + s")]
+    [InlineData("s + s + (c + s) + s")]
+    [InlineData("s + s + c + (s + s)")]
+    [InlineData("(s + s + c) + s + s")]
+    [InlineData("s + (s + c + s) + s")]
+    [InlineData("s + s + (c + s + s)")]
+    [InlineData("(s + s + c + s) + s")]
+    [InlineData("s + (s + c + s + s)")]
+    [InlineData("(s + s) + (c + s) + s")]
+    [InlineData("(s + s) + c + (s + s)")]
+    [InlineData("s + (s + c) + (s + s)")]
+    [InlineData("(s + s + c) + (s + s)")]
+    [InlineData("(s + s) + (c + s + s)")]
+    [InlineData("string.Concat(s, s) + c + s + s")]
+    [InlineData("s + string.Concat(s, c.ToString()) + s + s")]
+    [InlineData("s + s + string.Concat(c.ToString(), s) + s")]
+    [InlineData("s + s + c + string.Concat(s, s)")]
+    [InlineData("string.Concat(s, s, c.ToString()) + s + s")]
+    [InlineData("s + string.Concat(s, c.ToString(), s) + s")]
+    [InlineData("s + s + string.Concat(c.ToString(), s, s)")]
+    [InlineData("string.Concat(s, s, c.ToString(), s) + s")]
+    [InlineData("s + string.Concat(s, c.ToString(), s, s)")]
+    [InlineData("string.Concat(s, s) + string.Concat(c.ToString(), s) + s")]
+    [InlineData("string.Concat(s, s) + c + string.Concat(s, s)")]
+    [InlineData("s + string.Concat(s, c.ToString()) + string.Concat(s, s)")]
+    [InlineData("string.Concat(s, s, c.ToString()) + string.Concat(s, s)")]
+    [InlineData("string.Concat(s, s) + string.Concat(c.ToString(), s, s)")]
+    public void ConcatFive_Char_OperandGroupingAndUserInputOfStringBasedConcats(string expression)
+    {
+        var source = $$"""
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var s = "s";
+                    var c = 'c';
+                    Console.Write(M(s, c));
+                }
+
+                static string M(string s, char c) => {{expression}};
+            }
+            """;
+
+        var comp = CompileAndVerify(source, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "sscss" : null, targetFramework: TargetFramework.Net80, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        comp.VerifyDiagnostics();
+        comp.VerifyIL("Test.M", """
+            {
+              // Code size       38 (0x26)
+              .maxstack  4
+              IL_0000:  ldc.i4.5
+              IL_0001:  newarr     "string"
+              IL_0006:  dup
+              IL_0007:  ldc.i4.0
+              IL_0008:  ldarg.0
+              IL_0009:  stelem.ref
+              IL_000a:  dup
+              IL_000b:  ldc.i4.1
+              IL_000c:  ldarg.0
+              IL_000d:  stelem.ref
+              IL_000e:  dup
+              IL_000f:  ldc.i4.2
+              IL_0010:  ldarga.s   V_1
+              IL_0012:  call       "string char.ToString()"
+              IL_0017:  stelem.ref
+              IL_0018:  dup
+              IL_0019:  ldc.i4.3
+              IL_001a:  ldarg.0
+              IL_001b:  stelem.ref
+              IL_001c:  dup
+              IL_001d:  ldc.i4.4
+              IL_001e:  ldarg.0
+              IL_001f:  stelem.ref
+              IL_0020:  call       "string string.Concat(params string[])"
+              IL_0025:  ret
+            }
+            """);
+    }
+
+    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/66827")]
+    [InlineData(null)]
+    [InlineData((int)SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar)]
+    [InlineData((int)SpecialMember.System_ReadOnlySpan_T__ctor_Reference)]
+    [InlineData((int)SpecialMember.System_String__Concat_2ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_3ReadOnlySpans)]
+    [InlineData((int)SpecialMember.System_String__Concat_4ReadOnlySpans)]
+    public void ConcatFiveCharToStrings(int? missingUnimportantMember)
+    {
+        var source = """
+            using System;
+
+            public class Test
+            {
+                static void Main()
+                {
+                    var c1 = 'a';
+                    var c2 = 'b';
+                    var c3 = 'c';
+                    var c4 = 'd';
+                    var c5 = 'e';
+                    Console.Write(M(c1, c2, c3, c4, c5));
+                }
+
+                static string M(char c1, char c2, char c3, char c4, char c5) => c1.ToString() + c2.ToString() + c3.ToString() + c4.ToString() + c5.ToString();
+            }
+            """;
+
+        var comp = CreateCompilation(source, options: TestOptions.ReleaseExe, targetFramework: TargetFramework.Net80);
+
+        if (missingUnimportantMember.HasValue)
+        {
+            comp.MakeMemberMissing((SpecialMember)missingUnimportantMember.Value);
+        }
+
+        var verifier = CompileAndVerify(compilation: comp, expectedOutput: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? "abcde" : null, verify: RuntimeUtilities.IsCoreClr8OrHigherRuntime ? default : Verification.Skipped);
+
+        verifier.VerifyDiagnostics();
+        verifier.VerifyIL("Test.M", """
+            {
+              // Code size       62 (0x3e)
+              .maxstack  4
+              IL_0000:  ldc.i4.5
+              IL_0001:  newarr     "string"
+              IL_0006:  dup
+              IL_0007:  ldc.i4.0
+              IL_0008:  ldarga.s   V_0
+              IL_000a:  call       "string char.ToString()"
+              IL_000f:  stelem.ref
+              IL_0010:  dup
+              IL_0011:  ldc.i4.1
+              IL_0012:  ldarga.s   V_1
+              IL_0014:  call       "string char.ToString()"
+              IL_0019:  stelem.ref
+              IL_001a:  dup
+              IL_001b:  ldc.i4.2
+              IL_001c:  ldarga.s   V_2
+              IL_001e:  call       "string char.ToString()"
+              IL_0023:  stelem.ref
+              IL_0024:  dup
+              IL_0025:  ldc.i4.3
+              IL_0026:  ldarga.s   V_3
+              IL_0028:  call       "string char.ToString()"
+              IL_002d:  stelem.ref
+              IL_002e:  dup
+              IL_002f:  ldc.i4.4
+              IL_0030:  ldarga.s   V_4
+              IL_0032:  call       "string char.ToString()"
+              IL_0037:  stelem.ref
+              IL_0038:  call       "string string.Concat(params string[])"
+              IL_003d:  ret
+            }
+            """);
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/CompilationCreationTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/CompilationCreationTests.cs
index a16c746ef12fc..eabbebd3818b7 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/CompilationCreationTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/CompilationCreationTests.cs
@@ -80,7 +80,8 @@ public void CorLibTypes()
                 NamedTypeSymbol type = c1.GetSpecialType((SpecialType)i);
                 if (i is (int)SpecialType.System_Runtime_CompilerServices_RuntimeFeature or
                          (int)SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute or
-                         (int)SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute)
+                         (int)SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute or
+                         (int)SpecialType.System_ReadOnlySpan_T)
                 {
                     Assert.True(type.IsErrorType()); // Not available
                 }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/LoadingFields.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/LoadingFields.cs
index 1c0bc08a0f255..6b426817b160f 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/LoadingFields.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Metadata/PE/LoadingFields.cs
@@ -4,12 +4,12 @@
 
 #nullable disable
 
-using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
+using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
-using System.Linq;
 using Xunit;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Symbols.Metadata.PE
@@ -140,5 +140,17 @@ static void Main()
             CompileAndVerify(compilation, expectedOutput: @"Value1
 Value2");
         }
+
+        [Fact]
+        public void TestLoadFieldsOfReadOnlySpanFromCorlib()
+        {
+            var comp = CreateCompilation("", targetFramework: TargetFramework.Net60);
+
+            var readOnlySpanType = comp.GetSpecialType(SpecialType.System_ReadOnlySpan_T);
+            Assert.False(readOnlySpanType.IsErrorType());
+
+            var fields = readOnlySpanType.GetMembers().OfType<FieldSymbol>();
+            Assert.NotEmpty(fields);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
index d8dbb3d409388..645100119fac1 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
@@ -532,7 +532,8 @@ public void AllSpecialTypes()
 
                 if (special is SpecialType.System_Runtime_CompilerServices_RuntimeFeature or
                                SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute or
-                               SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute)
+                               SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute or
+                               SpecialType.System_ReadOnlySpan_T)
                 {
                     Assert.Equal(SymbolKind.ErrorType, symbol.Kind); // Not available
                 }
@@ -554,14 +555,19 @@ public void AllSpecialTypeMembers()
                 if (special == SpecialMember.Count) continue; // Not a real value;
 
                 var symbol = comp.GetSpecialTypeMember(special);
-                if (special == SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__DefaultImplementationsOfInterfaces
+                if (special == SpecialMember.System_String__Concat_2ReadOnlySpans
+                    || special == SpecialMember.System_String__Concat_3ReadOnlySpans
+                    || special == SpecialMember.System_String__Concat_4ReadOnlySpans
+                    || special == SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar
+                    || special == SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__DefaultImplementationsOfInterfaces
                     || special == SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__CovariantReturnsOfClasses
                     || special == SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__VirtualStaticsInInterfaces
                     || special == SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__UnmanagedSignatureCallingConvention
                     || special == SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__NumericIntPtr
                     || special == SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__ByRefFields
                     || special == SpecialMember.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute__ctor
-                    || special == SpecialMember.System_Runtime_CompilerServices_InlineArrayAttribute__ctor)
+                    || special == SpecialMember.System_Runtime_CompilerServices_InlineArrayAttribute__ctor
+                    || special == SpecialMember.System_ReadOnlySpan_T__ctor_Reference)
                 {
                     Assert.Null(symbol); // Not available
                 }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/ClsComplianceTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/ClsComplianceTests.cs
index 862c6a8f5c116..6b409bd315dd5 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/ClsComplianceTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/ClsComplianceTests.cs
@@ -8,7 +8,6 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -3166,6 +3165,7 @@ public class C
                     case SpecialType.System_Runtime_CompilerServices_RuntimeFeature: // static and not available
                     case SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute: // not available
                     case SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute: // not available
+                    case SpecialType.System_ReadOnlySpan_T: // not available
                         continue;
                 }
 
diff --git a/src/Compilers/Core/Portable/PublicAPI.Shipped.txt b/src/Compilers/Core/Portable/PublicAPI.Shipped.txt
index 496cc20f14b21..c7de3bf377049 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Shipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Shipped.txt
@@ -2542,7 +2542,7 @@ Microsoft.CodeAnalysis.SourceProductionContext.SourceProductionContext() -> void
 Microsoft.CodeAnalysis.SourceReferenceResolver
 Microsoft.CodeAnalysis.SourceReferenceResolver.SourceReferenceResolver() -> void
 Microsoft.CodeAnalysis.SpecialType
-Microsoft.CodeAnalysis.SpecialType.Count = 46 -> Microsoft.CodeAnalysis.SpecialType
+Microsoft.CodeAnalysis.SpecialType.Count = 47 -> Microsoft.CodeAnalysis.SpecialType
 Microsoft.CodeAnalysis.SpecialType.None = 0 -> Microsoft.CodeAnalysis.SpecialType
 Microsoft.CodeAnalysis.SpecialType.System_ArgIterator = 37 -> Microsoft.CodeAnalysis.SpecialType
 Microsoft.CodeAnalysis.SpecialType.System_Array = 23 -> Microsoft.CodeAnalysis.SpecialType
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index e5fe82d74f013..f2e84ea506234 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -13,6 +13,7 @@ Microsoft.CodeAnalysis.Operations.ISpreadOperation
 Microsoft.CodeAnalysis.Operations.ISpreadOperation.ElementConversion.get -> Microsoft.CodeAnalysis.Operations.CommonConversion
 Microsoft.CodeAnalysis.Operations.ISpreadOperation.ElementType.get -> Microsoft.CodeAnalysis.ITypeSymbol?
 Microsoft.CodeAnalysis.Operations.ISpreadOperation.Operand.get -> Microsoft.CodeAnalysis.IOperation!
+Microsoft.CodeAnalysis.SpecialType.System_ReadOnlySpan_T = 47 -> Microsoft.CodeAnalysis.SpecialType
 Microsoft.CodeAnalysis.SeparatedSyntaxList
 Microsoft.CodeAnalysis.SyntaxList
 static Microsoft.CodeAnalysis.SeparatedSyntaxList.Create<TNode>(System.ReadOnlySpan<TNode!> nodes) -> Microsoft.CodeAnalysis.SeparatedSyntaxList<TNode!>
diff --git a/src/Compilers/Core/Portable/SpecialMember.cs b/src/Compilers/Core/Portable/SpecialMember.cs
index 67d1817f74472..b75843664d326 100644
--- a/src/Compilers/Core/Portable/SpecialMember.cs
+++ b/src/Compilers/Core/Portable/SpecialMember.cs
@@ -19,6 +19,10 @@ internal enum SpecialMember
         System_String__ConcatObjectObjectObject,
         System_String__ConcatObjectArray,
 
+        System_String__Concat_2ReadOnlySpans,
+        System_String__Concat_3ReadOnlySpans,
+        System_String__Concat_4ReadOnlySpans,
+
         System_String__op_Equality,
         System_String__op_Inequality,
         System_String__Length,
@@ -26,6 +30,8 @@ internal enum SpecialMember
         System_String__Format,
         System_String__Substring,
 
+        System_String__op_Implicit_ToReadOnlySpanOfChar,
+
         System_Double__IsNaN,
         System_Single__IsNaN,
 
@@ -159,6 +165,8 @@ internal enum SpecialMember
         System_Runtime_CompilerServices_PreserveBaseOverridesAttribute__ctor,
         System_Runtime_CompilerServices_InlineArrayAttribute__ctor,
 
+        System_ReadOnlySpan_T__ctor_Reference,
+
         Count
     }
 }
diff --git a/src/Compilers/Core/Portable/SpecialMembers.cs b/src/Compilers/Core/Portable/SpecialMembers.cs
index a84c53e905f9d..776dfbb7d5b0b 100644
--- a/src/Compilers/Core/Portable/SpecialMembers.cs
+++ b/src/Compilers/Core/Portable/SpecialMembers.cs
@@ -97,6 +97,54 @@ static SpecialMembers()
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String,
                     (byte)SignatureTypeCode.SZArray, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Object,
 
+                // System_String__Concat_2ReadOnlySpans
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                            // Flags
+                (byte)SpecialType.System_String,                                                                            // DeclaringTypeId
+                0,                                                                                                          // Arity
+                    2,                                                                                                      // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+
+                // System_String__Concat_3ReadOnlySpans
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                            // Flags
+                (byte)SpecialType.System_String,                                                                            // DeclaringTypeId
+                0,                                                                                                          // Arity
+                    3,                                                                                                      // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+
+                // System_String__Concat_4ReadOnlySpans
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                            // Flags
+                (byte)SpecialType.System_String,                                                                            // DeclaringTypeId
+                0,                                                                                                          // Arity
+                    4,                                                                                                      // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+
                 // System_String__op_Equality
                 (byte)(MemberFlags.Method | MemberFlags.Static),                                                            // Flags
                 (byte)SpecialType.System_String,                                                                            // DeclaringTypeId
@@ -148,6 +196,16 @@ static SpecialMembers()
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
 
+                // System_String__op_Implicit_ToReadOnlySpanOfChar
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                            // Flags
+                (byte)SpecialType.System_String,                                                                            // DeclaringTypeId
+                0,                                                                                                          // Arity
+                    1,                                                                                                      // Method Signature
+                    (byte)SignatureTypeCode.GenericTypeInstance, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_ReadOnlySpan_T,
+                    1,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Char,
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String,
+
                 // System_Double__IsNaN
                 (byte)(MemberFlags.Method | MemberFlags.Static),                                                            // Flags
                 (byte)SpecialType.System_Double,                                                                            // DeclaringTypeId
@@ -1060,6 +1118,14 @@ static SpecialMembers()
                     1,                                                                                                      // Method Signature
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void, // Return Type
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
+
+                // System_ReadOnlySpan_T__ctor_Reference
+                (byte)MemberFlags.Constructor,                                                                              // Flags
+                (byte)SpecialType.System_ReadOnlySpan_T,                                                                    // DeclaringTypeId
+                0,                                                                                                          // Arity
+                    1,                                                                                                      // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void, // Return Type
+                    (byte)SignatureTypeCode.ByReference, (byte)SignatureTypeCode.GenericTypeParameter, 0,
             };
 
             string[] allNames = new string[(int)SpecialMember.Count]
@@ -1073,12 +1139,16 @@ static SpecialMembers()
                 "Concat",                                   // System_String__ConcatObjectObject
                 "Concat",                                   // System_String__ConcatObjectObjectObject
                 "Concat",                                   // System_String__ConcatObjectArray
+                "Concat",                                   // System_String__Concat_2ReadOnlySpans
+                "Concat",                                   // System_String__Concat_3ReadOnlySpans
+                "Concat",                                   // System_String__Concat_4ReadOnlySpans
                 "op_Equality",                              // System_String__op_Equality
                 "op_Inequality",                            // System_String__op_Inequality
                 "get_Length",                               // System_String__Length
                 "get_Chars",                                // System_String__Chars
                 "Format",                                   // System_String__Format
                 "Substring",                                // System_String__Substring
+                "op_Implicit",                              // System_String__op_Implicit_ToReadOnlySpanOfChar
                 "IsNaN",                                    // System_Double__IsNaN
                 "IsNaN",                                    // System_Single__IsNaN
                 "Combine",                                  // System_Delegate__Combine
@@ -1193,6 +1263,7 @@ static SpecialMembers()
                 "ByRefFields",                              // System_Runtime_CompilerServices_RuntimeFeature__ByRefFields
                 ".ctor",                                    // System_Runtime_CompilerServices_PreserveBaseOverridesAttribute__ctor
                 ".ctor",                                    // System_Runtime_CompilerServices_InlineArrayAttribute__ctor
+                ".ctor",                                    // System_ReadOnlySpan_T__ctor_Reference
             };
 
             s_descriptors = MemberDescriptor.InitializeFromStream(new System.IO.MemoryStream(initializationBytes, writable: false), allNames);
diff --git a/src/Compilers/Core/Portable/SpecialType.cs b/src/Compilers/Core/Portable/SpecialType.cs
index 66e5b3eb9d84d..aa98a07955669 100644
--- a/src/Compilers/Core/Portable/SpecialType.cs
+++ b/src/Compilers/Core/Portable/SpecialType.cs
@@ -263,9 +263,22 @@ public enum SpecialType : sbyte
         /// </summary>
         System_Runtime_CompilerServices_InlineArrayAttribute = 46,
 
+        /// <summary>
+        /// Indicates that the type is <see cref="System.ReadOnlySpan{T}"/> from the COR library.
+        /// </summary>
+        /// <remarks>
+        /// Check for this special type cannot be used to find the "canonical" definition of <see cref="ReadOnlySpan{T}"/>
+        /// since it is fully legal for it to come from sources other than the COR library, e.g. from `System.Memory` package.
+        /// The special type entry mostly exist so that compiler can tell this type apart when resolving other members of the COR library
+        /// </remarks>
+        System_ReadOnlySpan_T = 47,
+
         /// <summary>
         /// Count of special types. This is not a count of enum members.
         /// </summary>
-        Count = System_Runtime_CompilerServices_InlineArrayAttribute
+        /// <remarks>
+        /// The underlying numeric value of this member is expected to change every time a new special type is added
+        /// </remarks>
+        Count = System_ReadOnlySpan_T
     }
 }
diff --git a/src/Compilers/Core/Portable/SpecialTypeExtensions.cs b/src/Compilers/Core/Portable/SpecialTypeExtensions.cs
index 39ff0ce5f346d..afa94c7888812 100644
--- a/src/Compilers/Core/Portable/SpecialTypeExtensions.cs
+++ b/src/Compilers/Core/Portable/SpecialTypeExtensions.cs
@@ -87,6 +87,7 @@ public static bool IsValueType(this SpecialType specialType)
                 case SpecialType.System_RuntimeFieldHandle:
                 case SpecialType.System_RuntimeMethodHandle:
                 case SpecialType.System_RuntimeTypeHandle:
+                case SpecialType.System_ReadOnlySpan_T:
                     return true;
                 default:
                     return false;
@@ -354,5 +355,15 @@ public static SpecialType FromRuntimeTypeOfLiteralValue(object value)
 
             return SpecialType.None;
         }
+
+        /// <summary>
+        /// Tells whether a different code path can be taken based on the fact, that a given type is a special type.
+        /// This method is called in places where conditions like <c>specialType != SpecialType.None</c> were previously used.
+        /// The main reason for this method to exist is to prevent such conditions, which introduce silent code changes every time a new special type is added.
+        /// This doesn't mean the checked special type range of this method cannot be modified,
+        /// but rather that each usage of this method needs to be reviewed to make sure everything works as expected in such cases
+        /// </summary>
+        public static bool CanOptimizeBehavior(this SpecialType specialType)
+            => specialType is >= SpecialType.System_Object and <= SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute;
     }
 }
diff --git a/src/Compilers/Core/Portable/SpecialTypes.cs b/src/Compilers/Core/Portable/SpecialTypes.cs
index 163237fbfd8f3..0d1ae1dd58ab7 100644
--- a/src/Compilers/Core/Portable/SpecialTypes.cs
+++ b/src/Compilers/Core/Portable/SpecialTypes.cs
@@ -70,6 +70,7 @@ internal static class SpecialTypes
             "System.Runtime.CompilerServices.RuntimeFeature",
             "System.Runtime.CompilerServices.PreserveBaseOverridesAttribute",
             "System.Runtime.CompilerServices.InlineArrayAttribute",
+            "System.ReadOnlySpan`1",
         };
 
         private static readonly Dictionary<string, SpecialType> s_nameToTypeIdMap;
diff --git a/src/Compilers/Core/Portable/WellKnownMembers.cs b/src/Compilers/Core/Portable/WellKnownMembers.cs
index 8543293c72eb2..5bd237bc8f986 100644
--- a/src/Compilers/Core/Portable/WellKnownMembers.cs
+++ b/src/Compilers/Core/Portable/WellKnownMembers.cs
@@ -506,7 +506,7 @@ static WellKnownMembers()
                 (byte)WellKnownType.System_Collections_Generic_EqualityComparer_T,                                          // DeclaringTypeId
                 0,                                                                                                          // Arity
                     0,                                                                                                      // Method Signature
-                    (byte)SignatureTypeCode.TypeHandle, (byte)WellKnownType.System_Collections_Generic_EqualityComparer_T,// Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)WellKnownType.System_Collections_Generic_EqualityComparer_T,  // Return Type
 
                 // System_AttributeUsageAttribute__ctor
                 (byte)MemberFlags.Constructor,                                                                              // Flags
@@ -2663,7 +2663,7 @@ static WellKnownMembers()
 
                 // System_ValueTuple_T1__Item1
                 (byte)MemberFlags.Field,                                                                                    // Flags
-                (byte)WellKnownType.System_ValueTuple_T1,                                                                   // DeclaringTypeId
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.System_ValueTuple_T1 - WellKnownType.ExtSentinel),    // DeclaringTypeId
                 0,                                                                                                          // Arity
                     (byte)SignatureTypeCode.GenericTypeParameter, 0,                                                        // Field Signature
 
@@ -2879,7 +2879,7 @@ static WellKnownMembers()
 
                 // System_ValueTuple_T1__ctor
                 (byte)MemberFlags.Constructor,                                                                              // Flags
-                (byte)WellKnownType.System_ValueTuple_T1,                                                                   // DeclaringTypeId
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.System_ValueTuple_T1 - WellKnownType.ExtSentinel),    // DeclaringTypeId
                 0,                                                                                                          // Arity
                     1,                                                                                                      // Method Signature
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void, // Return Type
diff --git a/src/Compilers/Core/Portable/WellKnownTypes.cs b/src/Compilers/Core/Portable/WellKnownTypes.cs
index 960ee403d9e1d..2b93fedb5b26a 100644
--- a/src/Compilers/Core/Portable/WellKnownTypes.cs
+++ b/src/Compilers/Core/Portable/WellKnownTypes.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 
@@ -252,10 +251,10 @@ internal enum WellKnownType
         CSharp7Sentinel = System_IFormatProvider, // all types that were known before CSharp7 should remain above this sentinel
 
         System_ValueTuple,
-        System_ValueTuple_T1,
 
         ExtSentinel, // Not a real type, just a marker for types above 255 and strictly below 512
 
+        System_ValueTuple_T1,
         System_ValueTuple_T2,
         System_ValueTuple_T3,
         System_ValueTuple_T4,
@@ -585,10 +584,10 @@ internal static class WellKnownTypes
             "System.IFormatProvider",
 
             "System.ValueTuple",
-            "System.ValueTuple`1",
 
             "", // extension marker
 
+            "System.ValueTuple`1",
             "System.ValueTuple`2",
             "System.ValueTuple`3",
             "System.ValueTuple`4",
diff --git a/src/Compilers/VisualBasic/Portable/Analysis/FlowAnalysis/AbstractFlowPass.vb b/src/Compilers/VisualBasic/Portable/Analysis/FlowAnalysis/AbstractFlowPass.vb
index 06e77e63f2e2e..e5d1cafab45ad 100644
--- a/src/Compilers/VisualBasic/Portable/Analysis/FlowAnalysis/AbstractFlowPass.vb
+++ b/src/Compilers/VisualBasic/Portable/Analysis/FlowAnalysis/AbstractFlowPass.vb
@@ -2,18 +2,10 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
-Imports System
-Imports System.Collections.Generic
 Imports System.Collections.Immutable
-Imports System.Diagnostics
-Imports System.Linq
-Imports System.Text
+Imports System.Runtime.InteropServices
 Imports Microsoft.CodeAnalysis.PooledObjects
-Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
-Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
-Imports Roslyn.Utilities
-Imports System.Runtime.InteropServices
 
 ' NOTE: VB does not support constant expressions in flow analysis during command-line compilation, but supports them when 
 '       analysis is being called via public API. This distinction is governed by 'suppressConstantExpressions' flag
@@ -339,14 +331,31 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Return False
             End If
             Select Case type.SpecialType
-                Case SpecialType.None,
-                     SpecialType.System_Nullable_T,
-                     SpecialType.System_IntPtr,
-                     SpecialType.System_UIntPtr
-                    Return True
+                Case SpecialType.System_Void,
+                     SpecialType.System_Boolean,
+                     SpecialType.System_Char,
+                     SpecialType.System_SByte,
+                     SpecialType.System_Byte,
+                     SpecialType.System_Int16,
+                     SpecialType.System_UInt16,
+                     SpecialType.System_Int32,
+                     SpecialType.System_UInt32,
+                     SpecialType.System_Int64,
+                     SpecialType.System_UInt64,
+                     SpecialType.System_Decimal,
+                     SpecialType.System_Single,
+                     SpecialType.System_Double,
+                     SpecialType.System_DateTime,
+                     SpecialType.System_TypedReference,
+                     SpecialType.System_ArgIterator,
+                     SpecialType.System_RuntimeArgumentHandle,
+                     SpecialType.System_RuntimeFieldHandle,
+                     SpecialType.System_RuntimeMethodHandle,
+                     SpecialType.System_RuntimeTypeHandle
+                    Return False
 
                 Case Else
-                    Return False
+                    Return True
             End Select
         End Function
 
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb
index ca0198c7aca6b..7f75caa280d6a 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Metadata/PE/PENamedTypeSymbol.vb
@@ -1137,13 +1137,36 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
                         If Not import Then
                             Select Case Me.TypeKind
                                 Case TypeKind.Structure
-                                    Dim specialType = Me.SpecialType
-                                    If specialType = SpecialType.None OrElse specialType = SpecialType.System_Nullable_T Then
-                                        ' This is an ordinary struct
-                                        If ([module].GetFieldDefFlagsOrThrow(fieldDef) And FieldAttributes.Static) = 0 Then
-                                            import = True
-                                        End If
-                                    End If
+                                    Select Case Me.SpecialType
+                                        Case SpecialType.System_Void,
+                                             SpecialType.System_Boolean,
+                                             SpecialType.System_Char,
+                                             SpecialType.System_Byte,
+                                             SpecialType.System_SByte,
+                                             SpecialType.System_Int16,
+                                             SpecialType.System_UInt16,
+                                             SpecialType.System_Int32,
+                                             SpecialType.System_UInt32,
+                                             SpecialType.System_Int64,
+                                             SpecialType.System_UInt64,
+                                             SpecialType.System_Single,
+                                             SpecialType.System_Double,
+                                             SpecialType.System_Decimal,
+                                             SpecialType.System_IntPtr,
+                                             SpecialType.System_UIntPtr,
+                                             SpecialType.System_DateTime,
+                                             SpecialType.System_TypedReference,
+                                             SpecialType.System_ArgIterator,
+                                             SpecialType.System_RuntimeArgumentHandle,
+                                             SpecialType.System_RuntimeFieldHandle,
+                                             SpecialType.System_RuntimeMethodHandle,
+                                             SpecialType.System_RuntimeTypeHandle
+                                        Case Else
+                                            ' This is an ordinary struct
+                                            If ([module].GetFieldDefFlagsOrThrow(fieldDef) And FieldAttributes.Static) = 0 Then
+                                                import = True
+                                            End If
+                                    End Select
 
                                 Case TypeKind.Enum
                                     If ([module].GetFieldDefFlagsOrThrow(fieldDef) And FieldAttributes.Static) = 0 Then
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/CompilationCreationTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/CompilationCreationTests.vb
index 5bba005131b8d..a1ec028db8ab2 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/CompilationCreationTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/CompilationCreationTests.vb
@@ -96,7 +96,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
 
                 If i = SpecialType.System_Runtime_CompilerServices_RuntimeFeature OrElse
                    i = SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute OrElse
-                   i = SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute Then
+                   i = SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute OrElse
+                   i = SpecialType.System_ReadOnlySpan_T Then
                     Assert.Equal(type.Kind, SymbolKind.ErrorType) ' Not available
                 Else
                     Assert.NotEqual(type.Kind, SymbolKind.ErrorType)
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/LoadingFields.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/LoadingFields.vb
index 9faf012c72cdf..ac6a1308e615b 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/LoadingFields.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/LoadingFields.vb
@@ -2,14 +2,9 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
-Imports System.Runtime.CompilerServices
-Imports CompilationCreationTestHelpers
 Imports Microsoft.CodeAnalysis.Test.Utilities
-Imports Microsoft.CodeAnalysis.Text
-Imports Microsoft.CodeAnalysis.VisualBasic
-Imports Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
-Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
+Imports Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
 Imports Roslyn.Test.Utilities
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Symbols.Metadata.PE
@@ -276,6 +271,17 @@ End Module
 Value2")
         End Sub
 
+        <Fact>
+        Public Sub TestLoadFieldsOfReadOnlySpanFromCorlib()
+            Dim comp = CreateCompilation("", targetFramework:=TargetFramework.Net60)
+
+            Dim readOnlySpanType = comp.GetSpecialType(SpecialType.System_ReadOnlySpan_T)
+            Assert.False(readOnlySpanType.IsErrorType())
+
+            Dim fields = readOnlySpanType.GetMembers().OfType(Of FieldSymbol)()
+            Assert.NotEmpty(fields)
+        End Sub
+
     End Class
 
 End Namespace
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
index 0417509193df9..b4c46b675673a 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
@@ -2,7 +2,6 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
-Imports System.Xml.Linq
 Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Roslyn.Test.Utilities
 
@@ -456,7 +455,8 @@ End Namespace
 
                 If special = SpecialType.System_Runtime_CompilerServices_RuntimeFeature OrElse
                    special = SpecialType.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute OrElse
-                   special = SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute Then
+                   special = SpecialType.System_Runtime_CompilerServices_InlineArrayAttribute OrElse
+                   special = SpecialType.System_ReadOnlySpan_T Then
                     Assert.Equal(SymbolKind.ErrorType, symbol.Kind) ' Not available
                 Else
                     Assert.NotEqual(SymbolKind.ErrorType, symbol.Kind)
@@ -484,14 +484,19 @@ End Namespace
 
                 Dim symbol = comp.GetSpecialTypeMember(special)
 
-                If special = SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__DefaultImplementationsOfInterfaces OrElse
+                If special = SpecialMember.System_String__Concat_2ReadOnlySpans OrElse
+                   special = SpecialMember.System_String__Concat_3ReadOnlySpans OrElse
+                   special = SpecialMember.System_String__Concat_4ReadOnlySpans OrElse
+                   special = SpecialMember.System_String__op_Implicit_ToReadOnlySpanOfChar OrElse
+                   special = SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__DefaultImplementationsOfInterfaces OrElse
                    special = SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__UnmanagedSignatureCallingConvention OrElse
                    special = SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__CovariantReturnsOfClasses OrElse
                    special = SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__VirtualStaticsInInterfaces OrElse
                    special = SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__NumericIntPtr OrElse
                    special = SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__ByRefFields OrElse
                    special = SpecialMember.System_Runtime_CompilerServices_PreserveBaseOverridesAttribute__ctor OrElse
-                   special = SpecialMember.System_Runtime_CompilerServices_InlineArrayAttribute__ctor Then
+                   special = SpecialMember.System_Runtime_CompilerServices_InlineArrayAttribute__ctor OrElse
+                   special = SpecialMember.System_ReadOnlySpan_T__ctor_Reference Then
                     Assert.Null(symbol) ' Not available
                 Else
                     Assert.NotNull(symbol)

From 6e4c3cedccf767125562258073f8c300c6940b6c Mon Sep 17 00:00:00 2001
From: Cole Tobin <coleharrisjohnson@gmail.com>
Date: Tue, 19 Mar 2024 12:14:28 -0400
Subject: [PATCH 120/170] Update __arglist.md (#72523)

Fix dead-link with Wayback Machine
---
 docs/compilers/CSharp/__arglist.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/compilers/CSharp/__arglist.md b/docs/compilers/CSharp/__arglist.md
index 2cf047c13dad8..760604c6e1415 100644
--- a/docs/compilers/CSharp/__arglist.md
+++ b/docs/compilers/CSharp/__arglist.md
@@ -3,7 +3,7 @@ __arglist
 
 [This is a placeholder. We need some more documentation here]
 
-What is the __arglist language extension, exactly?
+What is the `__arglist` language extension, exactly?
 AFAIK it's an undocumented C# feature that mimics C++'s varargs and is present to support interop with managed C and C++..
 
-See also [http://bartdesmet.net/blogs/bart/archive/2006/09/28/4473.aspx](http://bartdesmet.net/blogs/bart/archive/2006/09/28/4473.aspx)
+See also [http://bartdesmet.net/blogs/bart/archive/2006/09/28/4473.aspx](https://web.archive.org/web/20170322203441/http://bartdesmet.net/blogs/bart/archive/2006/09/28/4473.aspx)

From 1d019d5f9bb3b71cc87475183bbb2f3f3992d824 Mon Sep 17 00:00:00 2001
From: Samuel Delarosbil <126594693+sdelarosbil@users.noreply.github.com>
Date: Tue, 19 Mar 2024 12:26:56 -0400
Subject: [PATCH 121/170] Update
 src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs

Co-authored-by: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
---
 .../UseCollectionExpressionForArrayTests.cs                     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs b/src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs
index 2004bccfebaa5..bd5d41f38c5ce 100644
--- a/src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs
+++ b/src/Analyzers/CSharp/Tests/UseCollectionExpression/UseCollectionExpressionForArrayTests.cs
@@ -1107,7 +1107,7 @@ void X(int[] x) { }
         }.RunAsync();
     }
 
-    [Fact]
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/72337")]
     public async Task TestTargetTypedArgumentPrimaryConstructor1()
     {
         await new VerifyCS.Test

From c77453dcfeddb1cef717e0d778846fe8330a3ab6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 10:25:37 -0700
Subject: [PATCH 122/170] in progress

---
 .../Remote/ServiceHub/Host/AssetProvider.cs   | 32 ++++++++----------
 .../ServiceHub/Host/ChecksumSynchronizer.cs   | 33 +++++++++++--------
 2 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
index 75758a70003ab..b20886d0c22e5 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Serialization;
+using Microsoft.CodeAnalysis.SpellCheck;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Remote;
@@ -29,13 +30,6 @@ internal sealed partial class AssetProvider(Checksum solutionChecksum, SolutionA
     private readonly SolutionAssetCache _assetCache = assetCache;
     private readonly IAssetSource _assetSource = assetSource;
 
-    private T GetRequiredAsset<T>(Checksum checksum)
-    {
-        Contract.ThrowIfTrue(checksum == Checksum.Null);
-        Contract.ThrowIfFalse(_assetCache.TryGetAsset<T>(checksum, out var asset));
-        return asset;
-    }
-
     public override async ValueTask<T> GetAssetAsync<T>(
         AssetHint assetHint, Checksum checksum, CancellationToken cancellationToken)
     {
@@ -43,25 +37,27 @@ public override async ValueTask<T> GetAssetAsync<T>(
         if (_assetCache.TryGetAsset<T>(checksum, out var asset))
             return asset;
 
-        using var _ = PooledHashSet<Checksum>.GetInstance(out var checksums);
+        using var _1 = PooledHashSet<Checksum>.GetInstance(out var checksums);
         checksums.Add(checksum);
 
-        await this.SynchronizeAssetsAsync(assetHint, checksums, cancellationToken).ConfigureAwait(false);
+        using var _2 = PooledDictionary<Checksum, object>.GetInstance(out var results);
+        await this.SynchronizeAssetsAsync(assetHint, checksums, results, cancellationToken).ConfigureAwait(false);
 
-        return GetRequiredAsset<T>(checksum);
+        return (T)results[checksum];
     }
 
-    public async ValueTask<ImmutableArray<ValueTuple<Checksum, T>>> GetAssetsAsync<T>(
+    public async ValueTask<ImmutableArray<(Checksum checksum, T asset)>> GetAssetsAsync<T>(
         AssetHint assetHint, HashSet<Checksum> checksums, CancellationToken cancellationToken)
     {
+        using var _1 = PooledDictionary<Checksum, object>.GetInstance(out var results);
+
         // bulk synchronize checksums first
         var syncer = new ChecksumSynchronizer(this);
-        await syncer.SynchronizeAssetsAsync(assetHint, checksums, cancellationToken).ConfigureAwait(false);
+        await syncer.SynchronizeAssetsAsync(assetHint, checksums, results, cancellationToken).ConfigureAwait(false);
 
-        // this will be fast since we actually synchronized the checksums above.
-        using var _ = ArrayBuilder<ValueTuple<Checksum, T>>.GetInstance(checksums.Count, out var list);
-        foreach (var checksum in checksums)
-            list.Add(ValueTuple.Create(checksum, GetRequiredAsset<T>(checksum)));
+        using var _2 = ArrayBuilder<ValueTuple<Checksum, T>>.GetInstance(checksums.Count, out var list);
+        foreach (var (checksum, assetObject) in results)
+            list.Add((checksum, (T)assetObject));
 
         return list.ToImmutableAndClear();
     }
@@ -113,7 +109,7 @@ public async ValueTask SynchronizeProjectAssetsAsync(ProjectStateChecksums proje
     }
 
     public async ValueTask SynchronizeAssetsAsync(
-        AssetHint assetHint, HashSet<Checksum> checksums, CancellationToken cancellationToken)
+        AssetHint assetHint, HashSet<Checksum> checksums, Dictionary<Checksum, object> results, CancellationToken cancellationToken)
     {
         Contract.ThrowIfTrue(checksums.Contains(Checksum.Null));
         if (checksums.Count == 0)
@@ -136,7 +132,7 @@ public async ValueTask SynchronizeAssetsAsync(
             missingChecksumsCount = 0;
             foreach (var checksum in checksums)
             {
-                if (!_assetCache.TryGetAsset<object>(checksum, out _))
+                if (!_assetCache.TryGetAsset<object>(checksum, out var existing))
                 {
                     missingChecksums[missingChecksumsCount] = checksum;
                     missingChecksumsCount++;
diff --git a/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs b/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
index 420d033463e1b..4f784081c3a80 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
@@ -20,17 +20,23 @@ private readonly struct ChecksumSynchronizer(AssetProvider assetProvider)
 
         private readonly AssetProvider _assetProvider = assetProvider;
 
-        public async ValueTask SynchronizeAssetsAsync(AssetHint assetHint, HashSet<Checksum> checksums, CancellationToken cancellationToken)
+        public async ValueTask SynchronizeAssetsAsync(
+            AssetHint assetHint,
+            HashSet<Checksum> checksums,
+            Dictionary<Checksum, object> results,
+            CancellationToken cancellationToken)
         {
             using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
             {
-                await _assetProvider.SynchronizeAssetsAsync(assetHint, checksums, cancellationToken).ConfigureAwait(false);
+                await _assetProvider.SynchronizeAssetsAsync(assetHint, checksums, results, cancellationToken).ConfigureAwait(false);
             }
         }
 
         public async ValueTask SynchronizeSolutionAssetsAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
         {
             SolutionStateChecksums solutionChecksumObject;
+            using var _1 = PooledDictionary<Checksum, object>.GetInstance(out var map);
+
             using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
             {
                 // this will make 4 round trip to data source (VS) to get all assets that belong to the given solution checksum
@@ -43,18 +49,18 @@ public async ValueTask SynchronizeSolutionAssetsAsync(Checksum solutionChecksum,
 
                 // second, get direct children of the solution
                 {
-                    using var _ = PooledHashSet<Checksum>.GetInstance(out var checksums);
+                    using var _2 = PooledHashSet<Checksum>.GetInstance(out var checksums);
 
                     solutionChecksumObject.AddAllTo(checksums);
                     checksums.Remove(solutionChecksumObject.Checksum);
-                    await _assetProvider.SynchronizeAssetsAsync(assetHint: AssetHint.None, checksums, cancellationToken).ConfigureAwait(false);
+                    await _assetProvider.SynchronizeAssetsAsync(assetHint: AssetHint.None, checksums, map, cancellationToken).ConfigureAwait(false);
                 }
             }
 
             // third and last get direct children for all projects and documents in the solution 
             foreach (var project in solutionChecksumObject.Projects)
             {
-                var projectStateChecksums = _assetProvider.GetRequiredAsset<ProjectStateChecksums>(project.checksum);
+                var projectStateChecksums = (ProjectStateChecksums)map[project.checksum];
                 await SynchronizeProjectAssetsAsync(projectStateChecksums, cancellationToken).ConfigureAwait(false);
             }
         }
@@ -70,7 +76,8 @@ public async ValueTask SynchronizeProjectAssetsAsync(ProjectStateChecksums proje
         private async ValueTask SynchronizeProjectAssets_NoLockAsync(ProjectStateChecksums projectChecksum, CancellationToken cancellationToken)
         {
             // get children of project checksum objects at once
-            using var _ = PooledHashSet<Checksum>.GetInstance(out var checksums);
+            using var _1 = PooledHashSet<Checksum>.GetInstance(out var checksums);
+            using var _2 = PooledDictionary<Checksum, object>.GetInstance(out var map);
 
             checksums.Add(projectChecksum.Info);
             checksums.Add(projectChecksum.CompilationOptions);
@@ -83,23 +90,23 @@ private async ValueTask SynchronizeProjectAssets_NoLockAsync(ProjectStateChecksu
             AddAll(checksums, projectChecksum.AnalyzerConfigDocuments.Checksums);
 
             await _assetProvider.SynchronizeAssetsAsync(
-                assetHint: projectChecksum.ProjectId, checksums, cancellationToken).ConfigureAwait(false);
+                assetHint: projectChecksum.ProjectId, checksums, map, cancellationToken).ConfigureAwait(false);
 
             checksums.Clear();
 
-            CollectChecksumChildren(this, projectChecksum.Documents.Checksums);
-            CollectChecksumChildren(this, projectChecksum.AdditionalDocuments.Checksums);
-            CollectChecksumChildren(this, projectChecksum.AnalyzerConfigDocuments.Checksums);
+            CollectChecksumChildren(projectChecksum.Documents.Checksums);
+            CollectChecksumChildren(projectChecksum.AdditionalDocuments.Checksums);
+            CollectChecksumChildren(projectChecksum.AnalyzerConfigDocuments.Checksums);
 
             await _assetProvider.SynchronizeAssetsAsync(
-                assetHint: projectChecksum.ProjectId, checksums, cancellationToken).ConfigureAwait(false);
+                assetHint: projectChecksum.ProjectId, checksums, map, cancellationToken).ConfigureAwait(false);
 
-            void CollectChecksumChildren(ChecksumSynchronizer @this, ChecksumCollection collection)
+            void CollectChecksumChildren(ChecksumCollection collection)
             {
                 foreach (var checksum in collection)
                 {
                     // These DocumentStateChecksums must be here due to the synchronizing step that just happened above. 
-                    var checksumObject = @this._assetProvider.GetRequiredAsset<DocumentStateChecksums>(checksum);
+                    var checksumObject = (DocumentStateChecksums)map[checksum];
                     checksums.Add(checksumObject.Info);
                     checksums.Add(checksumObject.Text);
                 }

From 140f02ddbdde54c8cf06271e45d917ea59baefeb Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Tue, 19 Mar 2024 10:27:08 -0700
Subject: [PATCH 123/170] Fix potential exception in
 AssetProvider.SynchronizeAssetsAsync

In a perf fix I made last week, I assumed _assetCache wouldn't change underneath me during execution of SynchronizeAssetsAsync. That assumption is not true.

Now, if the asset cache changes such that the missingChecksums array is no longer sufficient to hold all missing checksums, then grow the array capacity such that it can hold additional entries that might now be missing.
---
 .../Remote/ServiceHub/Host/AssetProvider.cs       | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
index 75758a70003ab..479c22188a85f 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
@@ -138,6 +138,21 @@ public async ValueTask SynchronizeAssetsAsync(
             {
                 if (!_assetCache.TryGetAsset<object>(checksum, out _))
                 {
+                    if (missingChecksumsCount == missingChecksums.Length)
+                    {
+                        // This can happen if the asset cache has been modified by another thread during this method's execution.
+                        var newMissingChecksums = new Checksum[missingChecksumsCount * 2];
+                        Array.Copy(missingChecksums, newMissingChecksums, missingChecksumsCount);
+
+                        if (usePool)
+                        {
+                            s_checksumPool.Free(missingChecksums);
+                            usePool = false;
+                        }
+
+                        missingChecksums = newMissingChecksums;
+                    }
+
                     missingChecksums[missingChecksumsCount] = checksum;
                     missingChecksumsCount++;
                 }

From ea8d45096b1af5a9b3f684e438b9490568e99b6d Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 10:29:08 -0700
Subject: [PATCH 124/170] Fix

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

diff --git a/src/VisualStudio/Core/Test.Next/Services/VisualStudioDiagnosticAnalyzerExecutorTests.cs b/src/VisualStudio/Core/Test.Next/Services/VisualStudioDiagnosticAnalyzerExecutorTests.cs
index da0a8c01c60c0..98091183d44f1 100644
--- a/src/VisualStudio/Core/Test.Next/Services/VisualStudioDiagnosticAnalyzerExecutorTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/VisualStudioDiagnosticAnalyzerExecutorTests.cs
@@ -245,7 +245,7 @@ void Method()
         }
 
         private static InProcOrRemoteHostAnalyzerRunner CreateAnalyzerRunner()
-            => new(new DiagnosticAnalyzerInfoCache());
+            => new(enabled: true, new DiagnosticAnalyzerInfoCache());
 
         private static async Task<DiagnosticAnalysisResult> AnalyzeAsync(TestWorkspace workspace, ProjectId projectId, Type analyzerType, IdeAnalyzerOptions ideOptions, CancellationToken cancellationToken = default)
         {

From 04f679e1aded95c5a64d58788c83e5a5a7d22cd1 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 10:57:45 -0700
Subject: [PATCH 125/170] Be reseilient

---
 .../Remote/ServiceHub/Host/AssetProvider.cs   | 36 ++++++++++++++----
 .../ServiceHub/Host/ChecksumSynchronizer.cs   | 37 +++++++++++--------
 2 files changed, 49 insertions(+), 24 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
index 5fad717984c7e..c91671b864093 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
@@ -11,7 +11,6 @@
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Serialization;
-using Microsoft.CodeAnalysis.SpellCheck;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Remote;
@@ -109,7 +108,7 @@ public async ValueTask SynchronizeProjectAssetsAsync(ProjectStateChecksums proje
     }
 
     public async ValueTask SynchronizeAssetsAsync(
-        AssetHint assetHint, HashSet<Checksum> checksums, Dictionary<Checksum, object> results, CancellationToken cancellationToken)
+        AssetHint assetHint, HashSet<Checksum> checksums, Dictionary<Checksum, object>? results, CancellationToken cancellationToken)
     {
         Contract.ThrowIfTrue(checksums.Contains(Checksum.Null));
         if (checksums.Count == 0)
@@ -132,7 +131,11 @@ public async ValueTask SynchronizeAssetsAsync(
             missingChecksumsCount = 0;
             foreach (var checksum in checksums)
             {
-                if (!_assetCache.TryGetAsset<object>(checksum, out var existing))
+                if (_assetCache.TryGetAsset<object>(checksum, out var existing))
+                {
+                    AddResult(checksum, existing);
+                }
+                else
                 {
                     if (missingChecksumsCount == missingChecksums.Length)
                     {
@@ -154,17 +157,34 @@ public async ValueTask SynchronizeAssetsAsync(
                 }
             }
 
-            var missingChecksumsMemory = new ReadOnlyMemory<Checksum>(missingChecksums, 0, missingChecksumsCount);
-            var assets = await RequestAssetsAsync(assetHint, missingChecksumsMemory, cancellationToken).ConfigureAwait(false);
+            if (missingChecksumsCount > 0)
+            {
+                var missingChecksumsMemory = new ReadOnlyMemory<Checksum>(missingChecksums, 0, missingChecksumsCount);
+                var missingAssets = await RequestAssetsAsync(assetHint, missingChecksumsMemory, cancellationToken).ConfigureAwait(false);
 
-            Contract.ThrowIfTrue(missingChecksumsMemory.Length != assets.Length);
+                Contract.ThrowIfTrue(missingChecksumsMemory.Length != missingAssets.Length);
 
-            for (int i = 0, n = assets.Length; i < n; i++)
-                _assetCache.GetOrAdd(missingChecksums[i], assets[i]);
+                for (int i = 0, n = missingAssets.Length; i < n; i++)
+                {
+                    var missingChecksum = missingChecksums[i];
+                    var missingAsset = missingAssets[i];
+
+                    AddResult(missingChecksum, missingAsset);
+                    _assetCache.GetOrAdd(missingChecksum, missingAsset);
+                }
+            }
 
             if (usePool)
                 s_checksumPool.Free(missingChecksums);
         }
+
+        return;
+
+        void AddResult(Checksum checksum, object result)
+        {
+            if (results != null)
+                results[checksum] = result;
+        }
     }
 
     private async Task<ImmutableArray<object>> RequestAssetsAsync(
diff --git a/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs b/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
index 4f784081c3a80..1d4de027143ce 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
@@ -23,7 +23,7 @@ private readonly struct ChecksumSynchronizer(AssetProvider assetProvider)
         public async ValueTask SynchronizeAssetsAsync(
             AssetHint assetHint,
             HashSet<Checksum> checksums,
-            Dictionary<Checksum, object> results,
+            Dictionary<Checksum, object>? results,
             CancellationToken cancellationToken)
         {
             using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
@@ -35,7 +35,6 @@ public async ValueTask SynchronizeAssetsAsync(
         public async ValueTask SynchronizeSolutionAssetsAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
         {
             SolutionStateChecksums solutionChecksumObject;
-            using var _1 = PooledDictionary<Checksum, object>.GetInstance(out var map);
 
             using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
             {
@@ -49,18 +48,21 @@ public async ValueTask SynchronizeSolutionAssetsAsync(Checksum solutionChecksum,
 
                 // second, get direct children of the solution
                 {
-                    using var _2 = PooledHashSet<Checksum>.GetInstance(out var checksums);
+                    using var _ = PooledHashSet<Checksum>.GetInstance(out var checksums);
 
                     solutionChecksumObject.AddAllTo(checksums);
                     checksums.Remove(solutionChecksumObject.Checksum);
-                    await _assetProvider.SynchronizeAssetsAsync(assetHint: AssetHint.None, checksums, map, cancellationToken).ConfigureAwait(false);
+                    await _assetProvider.SynchronizeAssetsAsync(assetHint: AssetHint.None, checksums, results: null, cancellationToken).ConfigureAwait(false);
                 }
             }
 
             // third and last get direct children for all projects and documents in the solution 
-            foreach (var project in solutionChecksumObject.Projects)
+            foreach (var (projectChecksum, _) in solutionChecksumObject.Projects)
             {
-                var projectStateChecksums = (ProjectStateChecksums)map[project.checksum];
+                // These GetAssetAsync calls should be fast since they were just retrieved above.  There's a small
+                // chance the asset-cache GC pass may have cleaned them up, but that should be exceedingly rare.
+                var projectStateChecksums = await _assetProvider.GetAssetAsync<ProjectStateChecksums>(
+                    assetHint: AssetHint.None, projectChecksum, cancellationToken).ConfigureAwait(false);
                 await SynchronizeProjectAssetsAsync(projectStateChecksums, cancellationToken).ConfigureAwait(false);
             }
         }
@@ -76,8 +78,7 @@ public async ValueTask SynchronizeProjectAssetsAsync(ProjectStateChecksums proje
         private async ValueTask SynchronizeProjectAssets_NoLockAsync(ProjectStateChecksums projectChecksum, CancellationToken cancellationToken)
         {
             // get children of project checksum objects at once
-            using var _1 = PooledHashSet<Checksum>.GetInstance(out var checksums);
-            using var _2 = PooledDictionary<Checksum, object>.GetInstance(out var map);
+            using var _ = PooledHashSet<Checksum>.GetInstance(out var checksums);
 
             checksums.Add(projectChecksum.Info);
             checksums.Add(projectChecksum.CompilationOptions);
@@ -89,24 +90,28 @@ private async ValueTask SynchronizeProjectAssets_NoLockAsync(ProjectStateChecksu
             AddAll(checksums, projectChecksum.AdditionalDocuments.Checksums);
             AddAll(checksums, projectChecksum.AnalyzerConfigDocuments.Checksums);
 
+            // First synchronize all the top-level info about this project.
             await _assetProvider.SynchronizeAssetsAsync(
-                assetHint: projectChecksum.ProjectId, checksums, map, cancellationToken).ConfigureAwait(false);
+                assetHint: projectChecksum.ProjectId, checksums, results: null, cancellationToken).ConfigureAwait(false);
 
             checksums.Clear();
 
-            CollectChecksumChildren(projectChecksum.Documents.Checksums);
-            CollectChecksumChildren(projectChecksum.AdditionalDocuments.Checksums);
-            CollectChecksumChildren(projectChecksum.AnalyzerConfigDocuments.Checksums);
+            // Then synchronize the info about all the documents within.
+            await CollectChecksumChildrenAsync(this, projectChecksum.Documents.Checksums).ConfigureAwait(false);
+            await CollectChecksumChildrenAsync(this, projectChecksum.AdditionalDocuments.Checksums).ConfigureAwait(false);
+            await CollectChecksumChildrenAsync(this, projectChecksum.AnalyzerConfigDocuments.Checksums).ConfigureAwait(false);
 
             await _assetProvider.SynchronizeAssetsAsync(
-                assetHint: projectChecksum.ProjectId, checksums, map, cancellationToken).ConfigureAwait(false);
+                assetHint: projectChecksum.ProjectId, checksums, results: null, cancellationToken).ConfigureAwait(false);
 
-            void CollectChecksumChildren(ChecksumCollection collection)
+            async ValueTask CollectChecksumChildrenAsync(ChecksumSynchronizer @this, ChecksumCollection collection)
             {
                 foreach (var checksum in collection)
                 {
-                    // These DocumentStateChecksums must be here due to the synchronizing step that just happened above. 
-                    var checksumObject = (DocumentStateChecksums)map[checksum];
+                    // These GetAssetAsync calls should be fast since they were just retrieved above.  There's a small
+                    // chance the asset-cache GC pass may have cleaned them up, but that should be exceedingly rare.
+                    var checksumObject = await @this._assetProvider.GetAssetAsync<DocumentStateChecksums>(
+                        assetHint: projectChecksum.ProjectId, checksum, cancellationToken).ConfigureAwait(false);
                     checksums.Add(checksumObject.Info);
                     checksums.Add(checksumObject.Text);
                 }

From c74b5039c74183df95102448c90063986d311470 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 11:05:16 -0700
Subject: [PATCH 126/170] Update
 src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs

---
 src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs b/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
index 1d4de027143ce..abf8190c6b10d 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/ChecksumSynchronizer.cs
@@ -35,7 +35,6 @@ public async ValueTask SynchronizeAssetsAsync(
         public async ValueTask SynchronizeSolutionAssetsAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
         {
             SolutionStateChecksums solutionChecksumObject;
-
             using (await s_gate.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
             {
                 // this will make 4 round trip to data source (VS) to get all assets that belong to the given solution checksum

From 980a7d3582c506f476c73c1f0f67127cc6deda34 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 11:07:40 -0700
Subject: [PATCH 127/170] Task type

---
 src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
index c91671b864093..d78e8d46d348e 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
@@ -187,7 +187,7 @@ void AddResult(Checksum checksum, object result)
         }
     }
 
-    private async Task<ImmutableArray<object>> RequestAssetsAsync(
+    private async ValueTask<ImmutableArray<object>> RequestAssetsAsync(
         AssetHint assetHint, ReadOnlyMemory<Checksum> checksums, CancellationToken cancellationToken)
     {
 #if NETCOREAPP

From 7e0629a1cbfba4bec2140b94f1e74e154002b6a6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 11:36:32 -0700
Subject: [PATCH 128/170] use marshal

---
 .../Remote/ServiceHub/Host/AssetProvider.cs         | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
index d78e8d46d348e..fd72dfbe20d76 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Internal.Log;
@@ -48,17 +49,21 @@ public override async ValueTask<T> GetAssetAsync<T>(
     public async ValueTask<ImmutableArray<(Checksum checksum, T asset)>> GetAssetsAsync<T>(
         AssetHint assetHint, HashSet<Checksum> checksums, CancellationToken cancellationToken)
     {
-        using var _1 = PooledDictionary<Checksum, object>.GetInstance(out var results);
+        using var _ = PooledDictionary<Checksum, object>.GetInstance(out var results);
 
         // bulk synchronize checksums first
         var syncer = new ChecksumSynchronizer(this);
         await syncer.SynchronizeAssetsAsync(assetHint, checksums, results, cancellationToken).ConfigureAwait(false);
 
-        using var _2 = ArrayBuilder<ValueTuple<Checksum, T>>.GetInstance(checksums.Count, out var list);
+        var result = new (Checksum checksum, T asset)[checksums.Count];
+        var index = 0;
         foreach (var (checksum, assetObject) in results)
-            list.Add((checksum, (T)assetObject));
+        {
+            result[index] = (checksum, (T)assetObject);
+            index++;
+        }
 
-        return list.ToImmutableAndClear();
+        return ImmutableCollectionsMarshal.AsImmutableArray(result);
     }
 
     public async ValueTask SynchronizeSolutionAssetsAsync(Checksum solutionChecksum, CancellationToken cancellationToken)

From be360dfd606f86b0a44e809cc0a21fd387a39584 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 11:49:28 -0700
Subject: [PATCH 129/170] tests

---
 src/VisualStudio/Core/Test.Next/Services/AssetProviderTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/VisualStudio/Core/Test.Next/Services/AssetProviderTests.cs b/src/VisualStudio/Core/Test.Next/Services/AssetProviderTests.cs
index 2b2ab808fb6c0..58ed5c28a5928 100644
--- a/src/VisualStudio/Core/Test.Next/Services/AssetProviderTests.cs
+++ b/src/VisualStudio/Core/Test.Next/Services/AssetProviderTests.cs
@@ -83,7 +83,7 @@ public async Task TestAssetSynchronization()
             var assetSource = new SimpleAssetSource(workspace.Services.GetService<ISerializerService>(), map);
 
             var service = new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService<ISerializerService>());
-            await service.SynchronizeAssetsAsync(assetHint: AssetHint.None, new HashSet<Checksum>(map.Keys), CancellationToken.None);
+            await service.SynchronizeAssetsAsync(assetHint: AssetHint.None, new HashSet<Checksum>(map.Keys), results: null, CancellationToken.None);
 
             foreach (var kv in map)
             {

From 98cd097bf122677378692ebe952b71ab6e5bb013 Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Tue, 19 Mar 2024 13:55:17 -0700
Subject: [PATCH 130/170] Fix potential exception in
 AssetProvider.SynchronizeAssetsAsync (#72597)

In a perf fix I made last week, I assumed _assetCache wouldn't change underneath me during execution of SynchronizeAssetsAsync. That assumption is not true.

Now, if the asset cache changes such that the missingChecksums array is no longer sufficient to hold all missing checksums, then grow the array capacity such that it can hold additional entries that might now be missing.
---
 .../Remote/ServiceHub/Host/AssetProvider.cs       | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
index 75758a70003ab..479c22188a85f 100644
--- a/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
+++ b/src/Workspaces/Remote/ServiceHub/Host/AssetProvider.cs
@@ -138,6 +138,21 @@ public async ValueTask SynchronizeAssetsAsync(
             {
                 if (!_assetCache.TryGetAsset<object>(checksum, out _))
                 {
+                    if (missingChecksumsCount == missingChecksums.Length)
+                    {
+                        // This can happen if the asset cache has been modified by another thread during this method's execution.
+                        var newMissingChecksums = new Checksum[missingChecksumsCount * 2];
+                        Array.Copy(missingChecksums, newMissingChecksums, missingChecksumsCount);
+
+                        if (usePool)
+                        {
+                            s_checksumPool.Free(missingChecksums);
+                            usePool = false;
+                        }
+
+                        missingChecksums = newMissingChecksums;
+                    }
+
                     missingChecksums[missingChecksumsCount] = checksum;
                     missingChecksumsCount++;
                 }

From f756df4d6b7d0707660ebf91e6e99393eeaebc66 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 14:40:00 -0700
Subject: [PATCH 131/170] Share compilation when generators don't produce any
 generated files

---
 ...utionCompilationState.CompilationTracker_Generators.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker_Generators.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker_Generators.cs
index 86c138987fd7f..713ea49a143d0 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker_Generators.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker_Generators.cs
@@ -339,7 +339,13 @@ await newGeneratedDocuments.States.Values.SelectAsArrayAsync(
 
             // If we didn't null out this compilation, it means we can actually use it
             if (compilationWithStaleGeneratedTrees != null)
-                return (compilationWithStaleGeneratedTrees, oldGeneratedDocuments, generatorDriver);
+            {
+                // If there are no generated documents though, then just use the compilationWithoutGeneratedFiles so we
+                // only hold onto that single compilation from this point on.
+                return oldGeneratedDocuments.Count == 0
+                    ? (compilationWithoutGeneratedFiles, oldGeneratedDocuments, generatorDriver)
+                    : (compilationWithStaleGeneratedTrees, oldGeneratedDocuments, generatorDriver);
+            }
 
             // We produced new documents, so time to create new state for it
             var newGeneratedDocuments = new TextDocumentStates<SourceGeneratedDocumentState>(generatedDocumentsBuilder.ToImmutableAndClear());

From 8dbdf7d554958bce1700ab5aab3b744cbbae378e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Tue, 19 Mar 2024 14:44:59 -0700
Subject: [PATCH 132/170] remove unused usings

---
 .../SolutionCompilationState.CompilationTracker_Generators.cs   | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker_Generators.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker_Generators.cs
index 713ea49a143d0..73fbee3c5a223 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker_Generators.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker_Generators.cs
@@ -2,10 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Collections.Immutable;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
 using System.Threading;

From 721e3c9adb4d312ea2af757d5fe9ebd94740f236 Mon Sep 17 00:00:00 2001
From: David Barbet <dabarbet@microsoft.com>
Date: Tue, 19 Mar 2024 14:57:08 -0700
Subject: [PATCH 133/170] Remove workaround for .net7 r2r assembly loading
 issue

---
 .../ExportProviderBuilder.cs                           | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ExportProviderBuilder.cs b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ExportProviderBuilder.cs
index 2fd22304a6ddb..4ccebd2ed94d9 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ExportProviderBuilder.cs
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ExportProviderBuilder.cs
@@ -24,16 +24,6 @@ public static async Task<ExportProvider> CreateExportProviderAsync(ExtensionAsse
         var assemblyPaths = Directory.EnumerateFiles(baseDirectory, "Microsoft.CodeAnalysis*.dll");
         assemblyPaths = assemblyPaths.Concat(Directory.EnumerateFiles(baseDirectory, "Microsoft.ServiceHub*.dll"));
 
-        // Temporarily explicitly load the dlls we want to add to the MEF composition.  This is due to a runtime bug
-        // in the 7.0.4 runtime where the APIs MEF uses to load assemblies break with R2R assemblies.
-        // See https://github.com/dotnet/runtime/issues/83526
-        //
-        // Once a newer version of the runtime is widely available, we can remove this.
-        foreach (var path in assemblyPaths)
-        {
-            Assembly.LoadFrom(path);
-        }
-
         // DevKit assemblies are not shipped in the main language server folder
         // and not included in ExtensionAssemblyPaths (they get loaded into the default ALC).
         // So manually add them to the MEF catalog here.

From b2ea40f631ee9c921b8f3956056aac92ac257dd6 Mon Sep 17 00:00:00 2001
From: David Barbet <dabarbet@microsoft.com>
Date: Tue, 19 Mar 2024 15:06:53 -0700
Subject: [PATCH 134/170] Drop win32-ia32 language server support

---
 .../Microsoft.CodeAnalysis.LanguageServer.csproj                | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj
index 6fc0c24a51815..b628f743b2ed0 100644
--- a/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj
+++ b/src/Features/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Microsoft.CodeAnalysis.LanguageServer.csproj
@@ -47,7 +47,7 @@
          https://github.com/dotnet/dotnet/blob/main/repo-projects/roslyn.proj. For definitions of the TargetRid
          and other common properties, see https://github.com/dotnet/arcade/blob/main/Documentation/UnifiedBuild/Unified-Build-Controls.md -->
     <RuntimeIdentifiers Condition="'$(TargetRid)' != ''">$(TargetRid)</RuntimeIdentifiers>
-    <RuntimeIdentifiers Condition="'$(TargetRid)' == ''">win-x64;win-x86;win-arm64;linux-x64;linux-arm64;linux-musl-x64;linux-musl-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    <RuntimeIdentifiers Condition="'$(TargetRid)' == ''">win-x64;win-arm64;linux-x64;linux-arm64;linux-musl-x64;linux-musl-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
     <!-- Publish ready to run executables when we're publishing platform specific executables. -->
     <PublishReadyToRun Condition="'$(RuntimeIdentifier)' != '' AND '$(Configuration)' == 'Release' ">true</PublishReadyToRun>
   </PropertyGroup>

From 2c76467c0c6600a797470fb0f3720e40497b96be Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Tue, 19 Mar 2024 20:46:31 -0700
Subject: [PATCH 135/170] Fix event hookup even when in a projection buffer

---
 .../EventHookup/EventHookupSessionManager.cs     |  4 ++--
 ...entHookupSessionManager_EventHookupSession.cs | 16 ++--------------
 2 files changed, 4 insertions(+), 16 deletions(-)

diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
index 5b1890636f6f0..13f8e5ba66166 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager.cs
@@ -52,7 +52,7 @@ internal void EventHookupFoundInSession(EventHookupSession analyzedSession, stri
         if (_toolTipPresenter == null &&
             CurrentSession == analyzedSession &&
             caretPoint.HasValue &&
-            IsCaretWithinSpanOrAtEnd(analyzedSession.TrackingSpan, analyzedSession.TextView.TextSnapshot, caretPoint.Value))
+            IsCaretWithinSpanOrAtEnd(analyzedSession.TrackingSpan, analyzedSession.SubjectBuffer.CurrentSnapshot, caretPoint.Value))
         {
             // Create a tooltip presenter that stays alive, even when the user types, without tracking the mouse.
             _toolTipPresenter = _toolTipService.CreatePresenter(analyzedSession.TextView,
@@ -174,7 +174,7 @@ private void Caret_PositionChanged(object sender, EventArgs e)
             DismissExistingSessions();
         }
 
-        var snapshotSpan = CurrentSession.TrackingSpan.GetSpan(CurrentSession.TextView.TextSnapshot);
+        var snapshotSpan = CurrentSession.TrackingSpan.GetSpan(CurrentSession.SubjectBuffer.CurrentSnapshot);
         if (snapshotSpan.Snapshot != caretPoint.Value.Snapshot || !snapshotSpan.Contains(caretPoint.Value))
         {
             DismissExistingSessions();
diff --git a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
index 344e5cadfd71e..aa1c6bdee8b93 100644
--- a/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
+++ b/src/EditorFeatures/CSharp/EventHookup/EventHookupSessionManager_EventHookupSession.cs
@@ -37,7 +37,6 @@ internal sealed partial class EventHookupSessionManager
     internal class EventHookupSession
     {
         private readonly IThreadingContext _threadingContext;
-        private readonly ITrackingPoint _trackingPoint;
         private readonly ITrackingSpan _trackingSpan;
         private readonly ITextView _textView;
         private readonly ITextBuffer _subjectBuffer;
@@ -51,15 +50,6 @@ internal class EventHookupSession
         private Task<string?>? _eventNameTask;
         private CancellationTokenSource? _cancellationTokenSource;
 
-        public ITrackingPoint TrackingPoint
-        {
-            get
-            {
-                _threadingContext.ThrowIfNotOnUIThread();
-                return _trackingPoint;
-            }
-        }
-
         public ITrackingSpan TrackingSpan
         {
             get
@@ -114,11 +104,9 @@ public EventHookupSession(
             _globalOptions = globalOptions;
             this.TESTSessionHookupMutex = testSessionHookupMutex;
 
-            _trackingPoint = textView.TextSnapshot.CreateTrackingPoint(position, PointTrackingMode.Negative);
-
             // If the caret is at the end of the document we just create an empty span
-            var length = textView.TextSnapshot.Length > position + 1 ? 1 : 0;
-            _trackingSpan = textView.TextSnapshot.CreateTrackingSpan(new Span(position, length), SpanTrackingMode.EdgeInclusive);
+            var length = subjectBuffer.CurrentSnapshot.Length > position + 1 ? 1 : 0;
+            _trackingSpan = subjectBuffer.CurrentSnapshot.CreateTrackingSpan(new Span(position, length), SpanTrackingMode.EdgeInclusive);
 
             var asyncToken = asyncListener.BeginAsyncOperation(GetType().Name + ".Start");
 

From e5112ac9b6c4b28b2adf3fb1c4c9dbf4d07e7303 Mon Sep 17 00:00:00 2001
From: Jan Jones <janjones@microsoft.com>
Date: Wed, 20 Mar 2024 07:25:42 +0100
Subject: [PATCH 136/170] [17.10] Bump roslyn-sdk and
 System.Security.Cryptography.Xml (#72458)

---
 eng/Directory.Packages.props                  |  6 ++-
 ...ateEqualsAndGetHashCodeFromMembersTests.cs |  4 +-
 .../CSharpMoveStaticMembersTests.cs           |  4 +-
 .../VisualBasicMoveStaticMembersTests.vb      |  4 +-
 .../ConvertToRecordCodeRefactoringTests.cs    | 40 +++++++++----------
 .../ExtractClass/ExtractClassTests.cs         |  4 +-
 .../CSharpCodeFixVerifier`2+Test.cs           |  4 +-
 .../CSharpCodeRefactoringVerifier`1+Test.cs   |  6 +--
 ...sualBasicCodeRefactoringVerifier`1+Test.cs |  6 +--
 9 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/eng/Directory.Packages.props b/eng/Directory.Packages.props
index 007be63e2f975..1018fa1767536 100644
--- a/eng/Directory.Packages.props
+++ b/eng/Directory.Packages.props
@@ -3,7 +3,7 @@
     <!-- Versions used by several individual references below -->
     <RoslynDiagnosticsNugetPackageVersion>3.11.0-beta1.24081.1</RoslynDiagnosticsNugetPackageVersion>
     <MicrosoftCodeAnalysisNetAnalyzersVersion>8.0.0-preview.23468.1</MicrosoftCodeAnalysisNetAnalyzersVersion>
-    <MicrosoftCodeAnalysisTestingVersion>1.1.2-beta1.23411.1</MicrosoftCodeAnalysisTestingVersion>
+    <MicrosoftCodeAnalysisTestingVersion>1.1.2-beta1.24121.1</MicrosoftCodeAnalysisTestingVersion>
     <MicrosoftVisualStudioExtensibilityTestingVersion>0.1.187-beta</MicrosoftVisualStudioExtensibilityTestingVersion>
     <!-- CodeStyleAnalyzerVersion should we updated together with version of dotnet-format in dotnet-tools.json -->
     <CodeStyleAnalyzerVersion>4.8.0-3.final</CodeStyleAnalyzerVersion>
@@ -274,7 +274,7 @@
     <PackageVersion Include="System.CodeDom" Version="7.0.0" />
     <PackageVersion Include="InputSimulatorPlus" Version="1.0.7" />
     <PackageVersion Include="UIAComWrapper" Version="1.1.0.14" />
-    <PackageVersion Include="DiffPlex" Version="1.5.0" />
+    <PackageVersion Include="DiffPlex" Version="1.7.2" />
     <PackageVersion Include="xunit" Version="$(xunitVersion)" />
     <PackageVersion Include="xunit.analyzers" Version="0.12.0-pre.20" />
     <PackageVersion Include="xunit.assert" Version="$(xunitVersion)" />
@@ -305,6 +305,8 @@
     When it updates its referenced System.Data.SqlClient version this should be removed
     -->
     <PackageVersion Include="System.Data.SqlClient" Version="4.8.6" />
+    <!-- fix of vulnerability in 6.0.0 coming via Microsoft.TeamFoundationServer.Client -->
+    <PackageVersion Include="System.Security.Cryptography.Xml" Version="7.0.1" />
     <!--
       Infra
     -->
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs
index 7be8166e8a502..ad045d21d1c9c 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeFromMembersTests.cs
@@ -37,7 +37,7 @@ private class TestWithDialog : VerifyCS.Test
             public ImmutableArray<string> MemberNames;
             public Action<ImmutableArray<PickMembersOption>> OptionsCallback;
 
-            protected override Workspace CreateWorkspaceImpl()
+            protected override Task<Workspace> CreateWorkspaceImplAsync()
             {
                 // If we're a dialog test, then mixin our mock and initialize its values to the ones the test asked for.
                 var workspace = new AdhocWorkspace(s_composition.GetHostServices());
@@ -46,7 +46,7 @@ protected override Workspace CreateWorkspaceImpl()
                 service.MemberNames = MemberNames;
                 service.OptionsCallback = OptionsCallback;
 
-                return workspace;
+                return Task.FromResult<Workspace>(workspace);
             }
         }
 
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/MoveStaticMembers/CSharpMoveStaticMembersTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/MoveStaticMembers/CSharpMoveStaticMembersTests.cs
index c3fc3b44e03d6..c4ec18b11129f 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/MoveStaticMembers/CSharpMoveStaticMembersTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/MoveStaticMembers/CSharpMoveStaticMembersTests.cs
@@ -3420,7 +3420,7 @@ public Test(
 
             private readonly bool _testPreselection;
 
-            protected override Workspace CreateWorkspaceImpl()
+            protected override Task<Workspace> CreateWorkspaceImplAsync()
             {
                 var hostServices = s_testServices.GetHostServices();
 
@@ -3432,7 +3432,7 @@ protected override Workspace CreateWorkspaceImpl()
                 testOptionsService.CreateNew = _createNew;
                 testOptionsService.ExpectedPrecheckedMembers = _testPreselection ? _selection : ImmutableArray<string>.Empty;
 
-                return workspace;
+                return Task.FromResult<Workspace>(workspace);
             }
         }
 
diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/MoveStaticMembers/VisualBasicMoveStaticMembersTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/MoveStaticMembers/VisualBasicMoveStaticMembersTests.vb
index 72238c6d39c5a..88f31223d1d0e 100644
--- a/src/EditorFeatures/VisualBasicTest/CodeActions/MoveStaticMembers/VisualBasicMoveStaticMembersTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/CodeActions/MoveStaticMembers/VisualBasicMoveStaticMembersTests.vb
@@ -3065,7 +3065,7 @@ End Namespace"
 
             Private ReadOnly _newType As Boolean
 
-            Protected Overrides Function CreateWorkspaceImpl() As Workspace
+            Protected Overrides Function CreateWorkspaceImplAsync() As Task(Of Workspace)
                 Dim hostServices = s_testServices.GetHostServices()
                 Dim workspace = New AdhocWorkspace(hostServices)
                 Dim optionsService = DirectCast(workspace.Services.GetRequiredService(Of IMoveStaticMembersOptionsService)(), TestMoveStaticMembersService)
@@ -3079,7 +3079,7 @@ End Namespace"
                 End If
                 optionsService.CreateNew = _newType
 
-                Return workspace
+                Return Task.FromResult(Of Workspace)(workspace)
             End Function
         End Class
 
diff --git a/src/Features/CSharpTest/ConvertToRecord/ConvertToRecordCodeRefactoringTests.cs b/src/Features/CSharpTest/ConvertToRecord/ConvertToRecordCodeRefactoringTests.cs
index 105c39fc1c568..816d363193c3f 100644
--- a/src/Features/CSharpTest/ConvertToRecord/ConvertToRecordCodeRefactoringTests.cs
+++ b/src/Features/CSharpTest/ConvertToRecord/ConvertToRecordCodeRefactoringTests.cs
@@ -4682,37 +4682,23 @@ public class C : [|B|]
 
     #endregion
 
-    private static void AddSolutionTransform(List<Func<Solution, ProjectId, Solution>> solutionTransforms)
-    {
-        solutionTransforms.Add((solution, projectId) =>
-        {
-            var project = solution.GetProject(projectId)!;
-
-            var compilationOptions = (CSharpCompilationOptions)project.CompilationOptions!;
-            // enable nullable
-            compilationOptions = compilationOptions.WithNullableContextOptions(NullableContextOptions.Enable);
-            solution = solution
-                .WithProjectCompilationOptions(projectId, compilationOptions)
-                .WithProjectMetadataReferences(projectId, TargetFrameworkUtil.GetReferences(TargetFramework.Net60));
-
-            return solution;
-        });
-    }
-
     private class RefactoringTest : VerifyCSRefactoring.Test
     {
         public RefactoringTest()
         {
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60;
             LanguageVersion = LanguageVersion.CSharp10;
-            AddSolutionTransform(SolutionTransforms);
             MarkupOptions = MarkupOptions.UseFirstDescriptor;
         }
 
-        protected override Workspace CreateWorkspaceImpl()
+        protected override CompilationOptions CreateCompilationOptions()
         {
-            var workspace = new AdhocWorkspace();
+            var compilationOptions = (CSharpCompilationOptions)base.CreateCompilationOptions();
+
+            // enable nullable
+            compilationOptions = compilationOptions.WithNullableContextOptions(NullableContextOptions.Enable);
 
-            return workspace;
+            return compilationOptions;
         }
     }
 
@@ -4744,8 +4730,18 @@ private class CodeFixTest :
     {
         public CodeFixTest()
         {
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60;
             LanguageVersion = LanguageVersion.CSharp10;
-            AddSolutionTransform(SolutionTransforms);
+        }
+
+        protected override CompilationOptions CreateCompilationOptions()
+        {
+            var compilationOptions = (CSharpCompilationOptions)base.CreateCompilationOptions();
+
+            // enable nullable
+            compilationOptions = compilationOptions.WithNullableContextOptions(NullableContextOptions.Enable);
+
+            return compilationOptions;
         }
     }
 
diff --git a/src/Features/CSharpTest/ExtractClass/ExtractClassTests.cs b/src/Features/CSharpTest/ExtractClass/ExtractClassTests.cs
index dc4874b417b72..dcbb359753ee7 100644
--- a/src/Features/CSharpTest/ExtractClass/ExtractClassTests.cs
+++ b/src/Features/CSharpTest/ExtractClass/ExtractClassTests.cs
@@ -48,11 +48,11 @@ protected override IEnumerable<CodeRefactoringProvider> GetCodeRefactoringProvid
                 return SpecializedCollections.SingletonEnumerable(new CSharpExtractClassCodeRefactoringProvider(service));
             }
 
-            protected override Workspace CreateWorkspaceImpl()
+            protected override Task<Workspace> CreateWorkspaceImplAsync()
             {
                 var unusedCompilationOptions = new CSharpCompilationOptions(OutputKind.NetModule);
                 var unusedParseOptions = new CSharpParseOptions(LanguageVersion.CSharp1);
-                return TestWorkspace.Create(WorkspaceKind, LanguageNames.CSharp, unusedCompilationOptions, unusedParseOptions);
+                return Task.FromResult<Workspace>(TestWorkspace.Create(WorkspaceKind, LanguageNames.CSharp, unusedCompilationOptions, unusedParseOptions));
             }
         }
 
diff --git a/src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs b/src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs
index 47aa1577c95b1..764d4aecab96b 100644
--- a/src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs
+++ b/src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs
@@ -113,16 +113,18 @@ protected override CodeFixContext CreateCodeFixContext(Document document, TextSp
 
             protected override FixAllContext CreateFixAllContext(
                 Document? document,
+                TextSpan? diagnosticSpan,
                 Project project,
                 CodeFixProvider codeFixProvider,
                 FixAllScope scope,
                 string? codeActionEquivalenceKey,
                 IEnumerable<string> diagnosticIds,
+                DiagnosticSeverity minimumSeverity,
                 FixAllContext.DiagnosticProvider fixAllDiagnosticProvider,
                 CancellationToken cancellationToken)
                 => new(new FixAllState(
                     fixAllProvider: NoOpFixAllProvider.Instance,
-                    diagnosticSpan: null,
+                    diagnosticSpan,
                     document,
                     project,
                     codeFixProvider,
diff --git a/src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs b/src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs
index d6b09794ab253..8898f89aaaf22 100644
--- a/src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs
+++ b/src/Features/DiagnosticsTestUtilities/CodeActions/CSharpCodeRefactoringVerifier`1+Test.cs
@@ -124,14 +124,14 @@ protected override CodeRefactoringContext CreateCodeRefactoringContext(Document
 
             private static readonly TestComposition s_editorFeaturesOOPComposition = FeaturesTestCompositions.Features.WithTestHostParts(TestHost.OutOfProcess);
 
-            protected override Workspace CreateWorkspaceImpl()
+            protected override Task<Workspace> CreateWorkspaceImplAsync()
             {
                 if (TestHost == TestHost.InProcess)
-                    return base.CreateWorkspaceImpl();
+                    return base.CreateWorkspaceImplAsync();
 
                 var hostServices = s_editorFeaturesOOPComposition.GetHostServices();
                 var workspace = new AdhocWorkspace(hostServices);
-                return workspace;
+                return Task.FromResult<Workspace>(workspace);
             }
 #endif
         }
diff --git a/src/Features/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs b/src/Features/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs
index ba5de08d3dc7c..fb2c5a1637488 100644
--- a/src/Features/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs
+++ b/src/Features/DiagnosticsTestUtilities/CodeActions/VisualBasicCodeRefactoringVerifier`1+Test.cs
@@ -110,14 +110,14 @@ protected override CodeRefactoringContext CreateCodeRefactoringContext(Document
 
             private static readonly TestComposition s_editorFeaturesOOPComposition = FeaturesTestCompositions.Features.WithTestHostParts(TestHost.OutOfProcess);
 
-            protected override Workspace CreateWorkspaceImpl()
+            protected override Task<Workspace> CreateWorkspaceImplAsync()
             {
                 if (TestHost == TestHost.InProcess)
-                    return base.CreateWorkspaceImpl();
+                    return base.CreateWorkspaceImplAsync();
 
                 var hostServices = s_editorFeaturesOOPComposition.GetHostServices();
                 var workspace = new AdhocWorkspace(hostServices);
-                return workspace;
+                return Task.FromResult<Workspace>(workspace);
             }
 
 #endif

From 76f8770d03deb70a6a16a375a7d5e2b67a3f11cf Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 10:51:06 -0700
Subject: [PATCH 137/170] Don't classify regex/json in binary string addition

---
 .../SemanticClassifierTests_Regex.cs          | 23 +++++++++++++++++++
 .../EmbeddedLanguageDetector.cs               | 13 +++++++++++
 .../Services/SyntaxFacts/CSharpSyntaxKinds.cs |  1 +
 .../Core/Services/SyntaxFacts/ISyntaxKinds.cs |  1 +
 .../SyntaxFacts/VisualBasicSyntaxKinds.vb     |  1 +
 5 files changed, 39 insertions(+)

diff --git a/src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests_Regex.cs b/src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests_Regex.cs
index 4de03a535266f..395eed27a1de5 100644
--- a/src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests_Regex.cs
+++ b/src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests_Regex.cs
@@ -1289,5 +1289,28 @@ void Goo()
                 Regex.OtherEscape("a"),
                 Regex.Comment("(?#comment)"));
         }
+
+        [Theory, CombinatorialData]
+        public async Task TestRegexNotOnBinaryExpression(TestHost testHost)
+        {
+            await TestAsync(
+                """
+                using System.Text.RegularExpressions;
+
+                class Program
+                {
+                    void Goo()
+                    {
+                        // language=regex
+                        var r = @"[a-" + @"z]";
+                    }
+                }
+                """,
+                testHost,
+                Namespace("System"),
+                Namespace("Text"),
+                Namespace("RegularExpressions"),
+                Keyword("var"));
+        }
     }
 }
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/EmbeddedLanguageDetector.cs b/src/Features/Core/Portable/EmbeddedLanguages/EmbeddedLanguageDetector.cs
index cf3f19833cc4c..5f67076ad07ff 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/EmbeddedLanguageDetector.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/EmbeddedLanguageDetector.cs
@@ -73,6 +73,19 @@ private bool HasLanguageComment(
         if (HasLanguageComment(token.GetPreviousToken().TrailingTrivia, syntaxFacts, out identifier, out options))
             return true;
 
+        // Check for the common case of a string literal in a large binary expression.  For example `"..." + "..." +
+        // "..."` We never want to consider these as regex/json tokens as processing them would require knowing the
+        // contents of every string literal, and having our lexers/parsers somehow stitch them all together.  This is
+        // beyond what those systems support (and would only work for constant strings anyways).  This prevents both
+        // incorrect results *and* avoids heavy perf hits walking up large binary expressions (often while a caller is
+        // themselves walking down such a large expression).
+        if (syntaxFacts.IsLiteralExpression(token.Parent) &&
+            syntaxFacts.IsBinaryExpression(token.Parent.Parent) &&
+            syntaxFacts.SyntaxKinds.AddExpression == token.Parent.Parent.RawKind)
+        {
+            return false;
+        }
+
         for (var node = token.Parent; node != null; node = node.Parent)
         {
             if (HasLanguageComment(node.GetLeadingTrivia(), syntaxFacts, out identifier, out options))
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs
index 7d24cd733e89f..c5e112ab1bc25 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Services/SyntaxFacts/CSharpSyntaxKinds.cs
@@ -84,6 +84,7 @@ public int Convert<TSyntaxKind>(TSyntaxKind kind) where TSyntaxKind : struct
     public int StringLiteralExpression => (int)SyntaxKind.StringLiteralExpression;
     public int TrueLiteralExpression => (int)SyntaxKind.TrueLiteralExpression;
 
+    public int AddExpression => (int)SyntaxKind.AddExpression;
     public int AddressOfExpression => (int)SyntaxKind.AddressOfExpression;
     public int AnonymousObjectCreationExpression => (int)SyntaxKind.AnonymousObjectCreationExpression;
     public int ArrayCreationExpression => (int)SyntaxKind.ArrayCreationExpression;
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs
index 82eaaee3f051f..4d304e6a3f4ae 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Services/SyntaxFacts/ISyntaxKinds.cs
@@ -126,6 +126,7 @@ internal interface ISyntaxKinds
 
     #region expressions
 
+    int AddExpression { get; }
     int AddressOfExpression { get; }
     int AnonymousObjectCreationExpression { get; }
     int ArrayCreationExpression { get; }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb
index 4fb0443365fa7..24f77d43ecd10 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/VisualBasic/Services/SyntaxFacts/VisualBasicSyntaxKinds.vb
@@ -86,6 +86,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.LanguageService
         Public ReadOnly Property StringLiteralExpression As Integer = SyntaxKind.StringLiteralExpression Implements ISyntaxKinds.StringLiteralExpression
         Public ReadOnly Property TrueLiteralExpression As Integer = SyntaxKind.TrueLiteralExpression Implements ISyntaxKinds.TrueLiteralExpression
 
+        Public ReadOnly Property AddExpression As Integer = SyntaxKind.AddExpression Implements ISyntaxKinds.AddExpression
         Public ReadOnly Property AddressOfExpression As Integer = SyntaxKind.AddressOfExpression Implements ISyntaxKinds.AddressOfExpression
         Public ReadOnly Property AnonymousObjectCreationExpression As Integer = SyntaxKind.AnonymousObjectCreationExpression Implements ISyntaxKinds.AnonymousObjectCreationExpression
         Public ReadOnly Property ArrayCreationExpression As Integer = SyntaxKind.ArrayCreationExpression Implements ISyntaxKinds.ArrayCreationExpression

From 20f2319a5770785a5b7b48eb1f882ca68b4d2eff Mon Sep 17 00:00:00 2001
From: juan-carlos-diaz <43589627+juan-carlos-diaz@users.noreply.github.com>
Date: Wed, 20 Mar 2024 14:08:44 -0400
Subject: [PATCH 138/170] Fix #69628 Analyzer summary should show suppressor ID
 (#72569)

* Show suppressor ids in analyser report

* Reuse old test

---------

Co-authored-by: Juan C. Diaz <juan.diaz@nicklaushealth.org>
---
 .../CSharp/Test/CommandLine/CommandLineTests.cs          | 3 ++-
 .../Core/Portable/CommandLine/ReportAnalyzerUtil.cs      | 9 ++++++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 4b1adefbb858d..63c7e533907ee 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -9353,13 +9353,14 @@ public void ReportAnalyzerOutput()
                 responseFile: null,
                 srcDirectory,
                 new[] { "/reportanalyzer", "/t:library", srcFile.Path },
-                analyzers: new[] { new WarningDiagnosticAnalyzer() },
+                analyzers: [new WarningDiagnosticAnalyzer(), new DiagnosticSuppressorForId("Warning01", "Suppressor01")],
                 generators: new[] { new DoNothingGenerator().AsSourceGenerator() });
             var exitCode = csc.Run(outWriter);
             Assert.Equal(0, exitCode);
             var output = outWriter.ToString();
             Assert.Contains(CodeAnalysisResources.AnalyzerExecutionTimeColumnHeader, output, StringComparison.Ordinal);
             Assert.Contains($"{nameof(WarningDiagnosticAnalyzer)} (Warning01)", output, StringComparison.Ordinal);
+            Assert.Contains($"{nameof(DiagnosticSuppressorForId)} (Suppressor01)", output, StringComparison.Ordinal);
             Assert.Contains(CodeAnalysisResources.GeneratorNameColumnHeader, output, StringComparison.Ordinal);
             Assert.Contains(typeof(DoNothingGenerator).FullName, output, StringComparison.Ordinal);
             CleanupAllGeneratedFiles(srcFile.Path);
diff --git a/src/Compilers/Core/Portable/CommandLine/ReportAnalyzerUtil.cs b/src/Compilers/Core/Portable/CommandLine/ReportAnalyzerUtil.cs
index 0cc9e6c857c83..218fc34d16cd8 100644
--- a/src/Compilers/Core/Portable/CommandLine/ReportAnalyzerUtil.cs
+++ b/src/Compilers/Core/Portable/CommandLine/ReportAnalyzerUtil.cs
@@ -93,7 +93,7 @@ private static void ReportAnalyzerExecutionTime(TextWriter consoleOutput, Analyz
                     executionTime = kvp.Value.TotalSeconds;
                     percentage = (int)(executionTime * 100 / totalAnalyzerExecutionTime);
 
-                    var analyzerIds = string.Join(", ", kvp.Key.SupportedDiagnostics.Select(d => d.Id).Distinct().OrderBy(id => id));
+                    var analyzerIds = string.Join(", ", GetSupportedIds(kvp.Key).Distinct().OrderBy(id => id));
                     var analyzerNameColumn = $"   {kvp.Key} ({analyzerIds})";
                     consoleOutput.WriteLine(GetColumnEntry(executionTime, percentage, analyzerNameColumn, culture));
                 }
@@ -102,6 +102,13 @@ private static void ReportAnalyzerExecutionTime(TextWriter consoleOutput, Analyz
             }
         }
 
+        private static IEnumerable<string> GetSupportedIds(DiagnosticAnalyzer analyzer)
+            => analyzer switch
+            {
+                DiagnosticSuppressor suppressor => suppressor.SupportedSuppressions.Select(s => s.Id),
+                _ => analyzer.SupportedDiagnostics.Select(d => d.Id),
+            };
+
         private static void ReportGeneratorExecutionTime(TextWriter consoleOutput, GeneratorDriverTimingInfo driverTimingInfo, CultureInfo culture)
         {
             if (driverTimingInfo.GeneratorTimes.IsEmpty)

From 59ebc4100e1c64e53782e67ab713a77c2e630833 Mon Sep 17 00:00:00 2001
From: Jan Jones <janjones@microsoft.com>
Date: Wed, 20 Mar 2024 19:34:51 +0100
Subject: [PATCH 139/170] Convert official pipeline to 1ES template (#72430)

---
 azure-pipelines-official.yml | 618 ++++++++++++++++++-----------------
 1 file changed, 310 insertions(+), 308 deletions(-)

diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index 355c9c2b8bc34..38536fad91be3 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -11,8 +11,11 @@ trigger:
 pr: none
 
 resources:
-- repo: self
-  clean: true
+  repositories:
+  - repository: 1ESPipelineTemplates
+    type: git
+    name: 1ESPipelineTemplates/1ESPipelineTemplates
+    ref: refs/tags/release
 
 parameters:
 - name: IbcDrop
@@ -52,6 +55,8 @@ variables:
   - group: DotNet-DevDiv-Insertion-Workflow-Variables
   - name: _DevDivDropAccessToken
     value: $(dn-bot-devdiv-drop-rw-code-rw)
+  - name: ArtifactServices.Drop.PAT
+    value: $(dn-bot-devdiv-drop-rw-code-rw)
   - group: DotNet-Roslyn-Insertion-Variables
 
   - name: BuildConfiguration
@@ -72,312 +77,309 @@ variables:
   - name: Insertion.TitleSuffix
     value: ''
 
-stages:
-
-- stage: build
-  displayName: Build and Test
-  pool:
-    name: NetCore1ESPool-Svc-Internal
-    demands: ImageOverride -equals windows.vs2022preview.amd64
-
-  jobs:
-  - ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/release/dev17.9') }}:
-    - template: /eng/common/templates/job/onelocbuild.yml
-      parameters:
-        MirrorRepo: roslyn
-        MirrorBranch: release/dev17.9
-        LclSource: lclFilesfromPackage
-        LclPackageId: 'LCL-JUNO-PROD-ROSLYN'
-
-  - template: eng/common/templates/jobs/source-build.yml
-
-  - job: OfficialBuild
-    displayName: Official Build
-    timeoutInMinutes: 360
-
-    steps:
-    - powershell: Write-Host "##vso[task.setvariable variable=SourceBranchName]$('$(Build.SourceBranch)'.Substring('refs/heads/'.Length))"
-      displayName: Setting SourceBranchName variable
-      condition: succeeded()
-
-    - task: Powershell@2
-      displayName: Tag official build
-      inputs:
-        targetType: inline
-        script: |
-          Write-Host "##vso[build.addBuildTag]OfficialBuild"
-      condition: succeeded()
-
-    # Don't run this while we don't have a main-vs-deps to merge. Should be uncommented when the branch comes back. Also need to change the condition of the tagging task above.
-    #
-    # - task: Powershell@2
-    #  displayName: Tag main validation build
-    #  inputs:
-    #    targetType: inline
-    #    script: |
-    #      Write-Host "##vso[build.addBuildTag]MainValidationBuild"
-    #  condition: and(succeeded(), eq(variables['SourceBranchName'], 'main'))
-
-    # Don't run this while we don't have a main-vs-deps to merge. Should be uncommented when the branch comes back.
-    #
-    # - task: PowerShell@2
-    #  displayName: Merge main-vs-deps into source branch
-    #  inputs:
-    #    filePath: 'scripts\merge-vs-deps.ps1'
-    #    arguments: '-accessToken $(dn-bot-dnceng-build-rw-code-rw)'
-    #  condition: and(succeeded(), eq(variables['SourceBranchName'], 'main'))
-
-    - powershell: Write-Host "##vso[task.setvariable variable=VisualStudio.DropName]Products/$(System.TeamProject)/$(Build.Repository.Name)/$(SourceBranchName)/$(Build.BuildNumber)"
-      displayName: Setting VisualStudio.DropName variable
-
-    - task: NodeTool@0
-      inputs:
-        versionSpec: '16.x'
-      displayName: 'Install Node.js'
-
-
-    - task: NuGetToolInstaller@0
-      inputs:
-        versionSpec: '4.9.2'
-
-    # Authenticate with service connections to be able to publish packages to external nuget feeds.
-    - task: NuGetAuthenticate@1
-      inputs:
-        nuGetServiceConnections: azure-public/vs-impl, azure-public/vssdk, devdiv/engineering, devdiv/dotnet-core-internal-tooling
-
-    # Needed for SBOM tool
-    - task: UseDotNet@2
-      displayName: 'Use .NET Core 3.1 runtime'
-      inputs:
-        packageType: runtime
-        version: 3.1.28
-        installationPath: '$(Build.SourcesDirectory)\.dotnet'
-
-    # Needed because the build fails the NuGet Tools restore without it
-    - task: UseDotNet@2
-      displayName: 'Use .NET Core sdk'
-      inputs:
-        packageType: sdk
-        useGlobalJson: true
-        workingDirectory: '$(Build.SourcesDirectory)'
-
-    # Needed to restore the Microsoft.DevDiv.Optimization.Data.PowerShell package
-    - task: NuGetCommand@2
-      displayName: Restore internal tools
-      inputs:
-        command: restore
-        feedsToUse: config
-        restoreSolution: 'eng\common\internal\Tools.csproj'
-        nugetConfigPath: 'NuGet.config'
-        restoreDirectory: '$(Build.SourcesDirectory)\.packages'
-
-    - task: MicroBuildSigningPlugin@4
-      inputs:
-        signType: $(SignType)
-        zipSources: false
-        feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
-      condition: and(succeeded(), in(variables['SignType'], 'test', 'real'))
-
-    - task: PowerShell@2
-      displayName: Build
-      inputs:
-        filePath: eng/build.ps1
-        arguments: -ci
-                   -prepareMachine
-                   -restore
-                   -build
-                   -pack
-                   -sign
-                   -publish
-                   -binaryLog
-                   -configuration $(BuildConfiguration)
-                   -officialBuildId $(Build.BuildNumber)
-                   -officialSkipTests $(SkipTests)
-                   -officialSkipApplyOptimizationData $(SkipApplyOptimizationData)
-                   -officialSourceBranchName $(SourceBranchName)
-                   -officialIbcDrop $(IbcDrop)
-                   -officialVisualStudioDropAccessToken $(_DevDivDropAccessToken)
-                   /p:RepositoryName=$(Build.Repository.Name)
-                   /p:VisualStudioDropName=$(VisualStudio.DropName)
-                   /p:DotNetSignType=$(SignType)
-                   /p:PublishToSymbolServer=true
-                   /p:DotNetArtifactsCategory=$(_DotNetArtifactsCategory)
-                   /p:DotnetPublishUsingPipelines=true
-                   /p:IgnoreIbcMergeErrors=true
-                   /p:GenerateSbom=true
-      condition: succeeded()
-      
-    - template: eng\common\templates\steps\generate-sbom.yml
-
-    - task: PowerShell@2
-      displayName: Publish Assets
-      inputs:
-        filePath: 'eng\publish-assets.ps1'
-        arguments: '-configuration $(BuildConfiguration) -branchName "$(SourceBranchName)"'
-      condition: succeeded()
-
-    # Publish OptProf configuration files
-    # The env variable is required to enable cross account access using PAT (dnceng -> devdiv)
-    - task: ms-vscs-artifact.build-tasks.artifactDropTask-1.artifactDropTask@0
-      env:
-        ARTIFACTSERVICES_DROP_PAT: $(_DevDivDropAccessToken)
-      inputs:
-        dropServiceURI: 'https://devdiv.artifacts.visualstudio.com'
-        buildNumber: 'ProfilingInputs/$(System.TeamProject)/$(Build.Repository.Name)/$(SourceBranchName)/$(Build.BuildNumber)'
-        sourcePath: '$(Build.SourcesDirectory)\artifacts\OptProf\$(BuildConfiguration)\Data'
-        toLowerCase: false
-        usePat: false
-        retentionDays: 90
-      displayName: 'OptProf - Publish to Artifact Services - ProfilingInputs'
-      condition: succeeded()
-
-    # Publish OptProf generated JSON files as a build artifact. This allows for easy inspection from
-    # a build execution.
-    - task: PublishBuildArtifacts@1
-      displayName: Publish OptProf Data Files
-      inputs:
-        PathtoPublish: '$(Build.SourcesDirectory)\artifacts\OptProf\$(BuildConfiguration)\Data'
-        ArtifactName: 'OptProf Data Files'
-      condition: succeeded()
-
-    - task: PublishBuildArtifacts@1
-      displayName: Publish Logs
-      inputs:
-        PathtoPublish: '$(Build.SourcesDirectory)\artifacts\log\$(BuildConfiguration)'
-        ArtifactName: 'Build Diagnostic Files'
-        publishLocation: Container
-      continueOnError: true
-      condition: succeededOrFailed()
-
-    - task: PublishBuildArtifacts@1
-      displayName: Publish Ngen Logs
-      inputs:
-        PathtoPublish: '$(Build.SourcesDirectory)\artifacts\log\$(BuildConfiguration)\ngen'
-        ArtifactName: 'NGen Logs'
-        publishLocation: Container
-      continueOnError: true
-      condition: succeeded()
-
-    - task: PublishTestResults@2
-      displayName: Publish xUnit Test Results
-      inputs:
-        testRunner: XUnit
-        testResultsFiles: '$(Build.SourcesDirectory)\artifacts\TestResults\$(BuildConfiguration)\*.xml'
-        mergeTestResults: true
-        testRunTitle: 'Unit Tests'
-      condition: and(succeededOrFailed(), ne(variables['SkipTests'], 'true'))
-
-    # Publishes setup VSIXes to a drop.
-    # Note: The insertion tool looks for the display name of this task in the logs.
-    - task: ms-vseng.MicroBuildTasks.4305a8de-ba66-4d8b-b2d1-0dc4ecbbf5e8.MicroBuildUploadVstsDropFolder@1
-      displayName: Upload VSTS Drop
-      inputs:
-        DropName: $(VisualStudio.DropName)
-        DropFolder: 'artifacts\VSSetup\$(BuildConfiguration)\Insertion'
-        AccessToken: $(_DevDivDropAccessToken)
-      condition: succeeded()
-
-    # Publish insertion packages to CoreXT store.
-    - task: NuGetCommand@2
-      displayName: Publish CoreXT Packages
-      inputs:
-        command: push
-        packagesToPush: '$(Build.SourcesDirectory)\artifacts\VSSetup\$(BuildConfiguration)\DevDivPackages\**\*.nupkg'
-        allowPackageConflicts: true
-        nuGetFeedType: external
-        publishFeedCredentials: 'DevDiv - VS package feed'
-      condition: succeeded()
-
-    # Publish an artifact that the RoslynInsertionTool is able to find by its name.
-    - task: PublishBuildArtifacts@1
-      displayName: Publish Artifact VSSetup
-      inputs:
-        PathtoPublish: 'artifacts\VSSetup\$(BuildConfiguration)'
-        ArtifactName: 'VSSetup'
-      condition: succeeded()
-
-    # Publish our NuPkgs as an artifact. The name of this artifact must be PackageArtifacts as the
-    # arcade templates depend on the name.
-    - task: PublishBuildArtifacts@1
-      displayName: Publish Artifact Packages
-      inputs:
-        PathtoPublish: 'artifacts\packages\$(BuildConfiguration)'
-        ArtifactName: 'PackageArtifacts'
-      condition: succeeded()
-
-    # Publish Asset Manifests for Build Asset Registry job
-    - task: PublishBuildArtifacts@1
-      displayName: Publish Asset Manifests
-      inputs:
-        PathtoPublish: '$(Build.SourcesDirectory)/artifacts/log/$(BuildConfiguration)/AssetManifest'
-        ArtifactName: AssetManifests
-      condition: succeeded()
-
-    - task: ms-vseng.MicroBuildTasks.521a94ea-9e68-468a-8167-6dcf361ea776.MicroBuildCleanup@1
-      displayName: Perform Cleanup Tasks
-      condition: succeededOrFailed()
-
-  # Publish to Build Asset Registry
-  - template: /eng/common/templates/job/publish-build-assets.yml
-    parameters:
-      publishUsingPipelines: true
-      dependsOn:
-        - OfficialBuild
-      pool:
+extends:
+  template: v1/1ES.Official.PipelineTemplate.yml@1ESPipelineTemplates
+  parameters:
+    featureFlags:
+      autoBaseline: true
+    sdl:
+      sourceAnalysisPool:
         name: NetCore1ESPool-Svc-Internal
-        demands: ImageOverride -equals windows.vs2022.amd64
-
-- stage: insert
-  dependsOn:
-  - publish_using_darc
-  displayName: Insert to VS
-
-  jobs:
-  - job: insert
-    displayName: Insert to VS
+        image: 1es-windows-2022-pt
+        os: windows
+      sbom:
+        enabled: false
     pool:
       name: NetCore1ESPool-Svc-Internal
-      demands: ImageOverride -equals windows.vs2022.amd64
-    steps:
-    - download: current
-      artifact: VSSetup
-    - powershell: |
-        $branchName = "$(Build.SourceBranch)".Substring("refs/heads/".Length)
-        Write-Host "##vso[task.setvariable variable=ComponentBranchName]$branchName"
-      displayName: Get Branch Name
-    - template: eng/pipelines/insert.yml
-      parameters:
-        buildUserName: "dn-bot@microsoft.com"
-        buildPassword: $(dn-bot-devdiv-build-e-code-full-release-e-packaging-r)
-        componentUserName: "dn-bot@microsoft.com"
-        componentPassword: $(dn-bot-dnceng-build-e-code-full-release-e-packaging-r)
-        componentBuildProjectName: internal
-        sourceBranch: "$(ComponentBranchName)"
-        publishDataURI: "https://dev.azure.com/dnceng/internal/_apis/git/repositories/dotnet-roslyn/items?path=eng/config/PublishData.json&api-version=6.0"
-        publishDataAccessToken: "$(System.AccessToken)"
-        dropPath: '$(Pipeline.Workspace)\VSSetup'
-
-- ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
-  - template: eng\common\templates\post-build\post-build.yml
-    parameters:
-      publishingInfraVersion: 3
-      # Symbol validation is not entirely reliable as of yet, so should be turned off until
-      # https://github.com/dotnet/arcade/issues/2871 is resolved.
-      enableSymbolValidation: false
-      enableSourceLinkValidation: false
-      # Enable SDL validation, passing through values from the 'DotNet-Roslyn-SDLValidation-Params' group.
-      SDLValidationParameters:
-        enable: true
-        params: >-
-          -SourceToolsList @("policheck","credscan")
-          -ArtifactToolsList @("binskim")
-          -BinskimAdditionalRunConfigParams @("IgnorePdbLoadError < True","Recurse < True","SymbolsPath < SRV*https://msdl.microsoft.com/download/symbols")
-          -TsaInstanceURL $(_TsaInstanceURL)
-          -TsaProjectName $(_TsaProjectName)
-          -TsaNotificationEmail $(_TsaNotificationEmail)
-          -TsaCodebaseAdmin $(_TsaCodebaseAdmin)
-          -TsaBugAreaPath $(_TsaBugAreaPath)
-          -TsaIterationPath $(_TsaIterationPath)
-          -TsaRepositoryName $(_TsaRepositoryName)
-          -TsaCodebaseName $(_TsaCodebaseName)
-          -TsaPublish $True
+      image: windows.vs2022preview.amd64
+      os: windows
+    customBuildTags:
+    - ES365AIMigrationTooling
+    stages:
+
+    - stage: build
+      displayName: Build and Test
+
+      jobs:
+      - ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/release/dev17.9') }}:
+        - template: /eng/common/templates-official/job/onelocbuild.yml@self
+          parameters:
+            MirrorRepo: roslyn
+            MirrorBranch: release/dev17.9
+            LclSource: lclFilesfromPackage
+            LclPackageId: 'LCL-JUNO-PROD-ROSLYN'
+
+      - template: /eng/common/templates-official/jobs/source-build.yml@self
+
+      - job: OfficialBuild
+        displayName: Official Build
+        timeoutInMinutes: 360
+        templateContext:
+          outputs:
+
+          # Publish OptProf generated JSON files as a pipeline artifact. This allows for easy inspection from
+          # a build execution.
+          - output: pipelineArtifact
+            displayName: 'Publish OptProf Data Files'
+            condition: succeeded()
+            targetPath: '$(Build.SourcesDirectory)\artifacts\OptProf\$(BuildConfiguration)\Data'
+            artifactName: 'OptProf Data Files'
+
+          - output: pipelineArtifact
+            displayName: 'Publish Logs'
+            condition: succeededOrFailed()
+            targetPath: '$(Build.SourcesDirectory)\artifacts\log\$(BuildConfiguration)'
+            artifactName: 'Build Diagnostic Files'
+            publishLocation: Container
+
+          - output: pipelineArtifact
+            displayName: 'Publish Ngen Logs'
+            condition: succeeded()
+            targetPath: '$(Build.SourcesDirectory)\artifacts\log\$(BuildConfiguration)\ngen'
+            artifactName: 'NGen Logs'
+            publishLocation: Container
+
+          # Publishes setup VSIXes to a drop.
+          # Note: The insertion tool looks for the display name of this task in the logs.
+          - output: microBuildVstsDrop
+            displayName: Upload VSTS Drop
+            condition: succeeded()
+            dropFolder: 'artifacts\VSSetup\$(BuildConfiguration)\Insertion'
+            dropName: $(VisualStudio.DropName)
+            accessToken: $(_DevDivDropAccessToken)
+
+          # Publish insertion packages to CoreXT store.
+          - output: nuget
+            displayName: 'Publish CoreXT Packages'
+            condition: succeeded()
+            packageParentPath: '$(Build.SourcesDirectory)\artifacts\VSSetup\$(BuildConfiguration)\DevDivPackages'
+            packagesToPush: '$(Build.SourcesDirectory)\artifacts\VSSetup\$(BuildConfiguration)\DevDivPackages\**\*.nupkg'
+            allowPackageConflicts: true
+            nuGetFeedType: external
+            publishFeedCredentials: 'DevDiv - VS package feed'
+
+          # Publish an artifact that the RoslynInsertionTool is able to find by its name.
+          - output: pipelineArtifact
+            displayName: 'Publish Artifact VSSetup'
+            condition: succeeded()
+            targetPath: 'artifacts\VSSetup\$(BuildConfiguration)'
+            artifactName: 'VSSetup'
+
+          # Publish our NuPkgs as an artifact. The name of this artifact must be PackageArtifacts as the
+          # arcade templates depend on the name.
+          - output: buildArtifacts
+            displayName: 'Publish Artifact Packages'
+            condition: succeeded()
+            PathtoPublish: 'artifacts\packages\$(BuildConfiguration)'
+            ArtifactName: 'PackageArtifacts'
+
+          # Publish Asset Manifests for Build Asset Registry job
+          - output: buildArtifacts
+            displayName: 'Publish Asset Manifests'
+            condition: succeeded()
+            PathtoPublish: '$(Build.SourcesDirectory)/artifacts/log/$(BuildConfiguration)/AssetManifest'
+            ArtifactName: AssetManifests
+
+        steps:
+        - powershell: Write-Host "##vso[task.setvariable variable=SourceBranchName]$('$(Build.SourceBranch)'.Substring('refs/heads/'.Length))"
+          displayName: Setting SourceBranchName variable
+          condition: succeeded()
+
+        - task: Powershell@2
+          displayName: Tag official build
+          inputs:
+            targetType: inline
+            script: |
+              Write-Host "##vso[build.addBuildTag]OfficialBuild"
+          condition: succeeded()
+
+        # Don't run this while we don't have a main-vs-deps to merge. Should be uncommented when the branch comes back. Also need to change the condition of the tagging task above.
+        #
+        # - task: Powershell@2
+        #  displayName: Tag main validation build
+        #  inputs:
+        #    targetType: inline
+        #    script: |
+        #      Write-Host "##vso[build.addBuildTag]MainValidationBuild"
+        #  condition: and(succeeded(), eq(variables['SourceBranchName'], 'main'))
+
+        # Don't run this while we don't have a main-vs-deps to merge. Should be uncommented when the branch comes back.
+        #
+        # - task: PowerShell@2
+        #  displayName: Merge main-vs-deps into source branch
+        #  inputs:
+        #    filePath: 'scripts\merge-vs-deps.ps1'
+        #    arguments: '-accessToken $(dn-bot-dnceng-build-rw-code-rw)'
+        #  condition: and(succeeded(), eq(variables['SourceBranchName'], 'main'))
+
+        - powershell: Write-Host "##vso[task.setvariable variable=VisualStudio.DropName]Products/$(System.TeamProject)/$(Build.Repository.Name)/$(SourceBranchName)/$(Build.BuildNumber)"
+          displayName: Setting VisualStudio.DropName variable
+
+        - task: NodeTool@0
+          inputs:
+            versionSpec: '16.x'
+          displayName: 'Install Node.js'
+
+        - task: NuGetToolInstaller@0
+          inputs:
+            versionSpec: '4.9.2'
+
+        # Authenticate with service connections to be able to publish packages to external nuget feeds.
+        - task: NuGetAuthenticate@1
+          inputs:
+            nuGetServiceConnections: azure-public/vs-impl, azure-public/vssdk, devdiv/engineering, devdiv/dotnet-core-internal-tooling
+
+        # Needed for SBOM tool
+        - task: UseDotNet@2
+          displayName: 'Use .NET Core 3.1 runtime'
+          inputs:
+            packageType: runtime
+            version: 3.1.28
+            installationPath: '$(Build.SourcesDirectory)\.dotnet'
+
+        # Needed because the build fails the NuGet Tools restore without it
+        - task: UseDotNet@2
+          displayName: 'Use .NET Core sdk'
+          inputs:
+            packageType: sdk
+            useGlobalJson: true
+            workingDirectory: '$(Build.SourcesDirectory)'
+
+        # Needed to restore the Microsoft.DevDiv.Optimization.Data.PowerShell package
+        - task: NuGetCommand@2
+          displayName: Restore internal tools
+          inputs:
+            command: restore
+            feedsToUse: config
+            restoreSolution: 'eng\common\internal\Tools.csproj'
+            nugetConfigPath: 'NuGet.config'
+            restoreDirectory: '$(Build.SourcesDirectory)\.packages'
+
+        - task: MicroBuildSigningPlugin@4
+          inputs:
+            signType: $(SignType)
+            zipSources: false
+            feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json
+          condition: and(succeeded(), in(variables['SignType'], 'test', 'real'))
+
+        - task: PowerShell@2
+          displayName: Build
+          inputs:
+            filePath: eng/build.ps1
+            arguments: -ci
+                       -prepareMachine
+                       -restore
+                       -build
+                       -pack
+                       -sign
+                       -publish
+                       -binaryLog
+                       -configuration $(BuildConfiguration)
+                       -officialBuildId $(Build.BuildNumber)
+                       -officialSkipTests $(SkipTests)
+                       -officialSkipApplyOptimizationData $(SkipApplyOptimizationData)
+                       -officialSourceBranchName $(SourceBranchName)
+                       -officialIbcDrop $(IbcDrop)
+                       -officialVisualStudioDropAccessToken $(_DevDivDropAccessToken)
+                       /p:RepositoryName=$(Build.Repository.Name)
+                       /p:VisualStudioDropName=$(VisualStudio.DropName)
+                       /p:DotNetSignType=$(SignType)
+                       /p:PublishToSymbolServer=true
+                       /p:DotNetArtifactsCategory=$(_DotNetArtifactsCategory)
+                       /p:DotnetPublishUsingPipelines=true
+                       /p:IgnoreIbcMergeErrors=true
+                       /p:GenerateSbom=true
+          condition: succeeded()
+
+        - template: /eng/common/templates-official/steps/generate-sbom.yml@self
+
+        - task: PowerShell@2
+          displayName: Publish Assets
+          inputs:
+            filePath: 'eng\publish-assets.ps1'
+            arguments: '-configuration $(BuildConfiguration) -branchName "$(SourceBranchName)"'
+          condition: succeeded()
+
+        # Publish OptProf configuration files to the artifact service
+        # This uses the ArtifactServices.Drop.PAT build variable which is required to enable cross account access using PAT (dnceng -> devdiv)
+        - task: 1ES.PublishArtifactsDrop@1
+          inputs:
+            dropServiceURI: 'https://devdiv.artifacts.visualstudio.com'
+            buildNumber: 'ProfilingInputs/$(System.TeamProject)/$(Build.Repository.Name)/$(SourceBranchName)/$(Build.BuildNumber)'
+            sourcePath: '$(Build.SourcesDirectory)\artifacts\OptProf\$(BuildConfiguration)\Data'
+            toLowerCase: false
+            usePat: false
+            retentionDays: 90
+          displayName: 'OptProf - Publish to Artifact Services - ProfilingInputs'
+          condition: succeeded()
+
+        - task: PublishTestResults@2
+          displayName: Publish xUnit Test Results
+          inputs:
+            testRunner: XUnit
+            testResultsFiles: '$(Build.SourcesDirectory)\artifacts\TestResults\$(BuildConfiguration)\*.xml'
+            mergeTestResults: true
+            testRunTitle: 'Unit Tests'
+          condition: and(succeededOrFailed(), ne(variables['SkipTests'], 'true'))
+
+      # Publish to Build Asset Registry
+      - template: /eng/common/templates-official/job/publish-build-assets.yml@self
+        parameters:
+          publishUsingPipelines: true
+          dependsOn:
+          - OfficialBuild
+          pool:
+            name: NetCore1ESPool-Svc-Internal
+            demands: ImageOverride -equals windows.vs2022.amd64
+
+    - stage: insert
+      dependsOn:
+      - publish_using_darc
+      displayName: Insert to VS
+
+      jobs:
+      - job: insert
+        displayName: Insert to VS
+        steps:
+        - download: current
+          artifact: VSSetup
+        - powershell: |
+            $branchName = "$(Build.SourceBranch)".Substring("refs/heads/".Length)
+            Write-Host "##vso[task.setvariable variable=ComponentBranchName]$branchName"
+          displayName: Get Branch Name
+        - template: /eng/pipelines/insert.yml@self
+          parameters:
+            buildUserName: "dn-bot@microsoft.com"
+            buildPassword: $(dn-bot-devdiv-build-e-code-full-release-e-packaging-r)
+            componentUserName: "dn-bot@microsoft.com"
+            componentPassword: $(dn-bot-dnceng-build-e-code-full-release-e-packaging-r)
+            componentBuildProjectName: internal
+            sourceBranch: "$(ComponentBranchName)"
+            publishDataURI: "https://dev.azure.com/dnceng/internal/_apis/git/repositories/dotnet-roslyn/items?path=eng/config/PublishData.json&api-version=6.0"
+            publishDataAccessToken: "$(System.AccessToken)"
+            dropPath: '$(Pipeline.Workspace)\VSSetup'
+
+    - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}:
+      - template: /eng/common/templates-official/post-build/post-build.yml@self
+        parameters:
+          publishingInfraVersion: 3
+          # Symbol validation is not entirely reliable as of yet, so should be turned off until
+          # https://github.com/dotnet/arcade/issues/2871 is resolved.
+          enableSymbolValidation: false
+          enableSourceLinkValidation: false
+          # Enable SDL validation, passing through values from the 'DotNet-Roslyn-SDLValidation-Params' group.
+          SDLValidationParameters:
+            enable: true
+            params: >-
+              -SourceToolsList @("policheck","credscan")
+              -ArtifactToolsList @("binskim")
+              -BinskimAdditionalRunConfigParams @("IgnorePdbLoadError < True","Recurse < True","SymbolsPath < SRV*https://msdl.microsoft.com/download/symbols")
+              -TsaInstanceURL $(_TsaInstanceURL)
+              -TsaProjectName $(_TsaProjectName)
+              -TsaNotificationEmail $(_TsaNotificationEmail)
+              -TsaCodebaseAdmin $(_TsaCodebaseAdmin)
+              -TsaBugAreaPath $(_TsaBugAreaPath)
+              -TsaIterationPath $(_TsaIterationPath)
+              -TsaRepositoryName $(_TsaRepositoryName)
+              -TsaCodebaseName $(_TsaCodebaseName)
+              -TsaPublish $True

From 23b8170ffc5382f957adb2642afdf3d192250e4f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 11:58:51 -0700
Subject: [PATCH 140/170] In progress

---
 .../InternalUtilities/EnumerableExtensions.cs | 96 +++++++++++++++++++
 ...tionCompilationState.CompilationTracker.cs | 25 +----
 ...pilationState.TranslationAction_Actions.cs | 27 ++++--
 .../Solution/SolutionCompilationState.cs      | 57 +++++++----
 4 files changed, 161 insertions(+), 44 deletions(-)

diff --git a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
index 6b7fbd4911be6..089b100bb0fa0 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
@@ -13,6 +13,8 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 using System.Threading;
+using Microsoft.CodeAnalysis.Collections.Internal;
+using System.Diagnostics;
 
 #if DEBUG
 using System.Diagnostics;
@@ -868,5 +870,99 @@ public static bool SequenceEqual<T>(this IEnumerable<T>? first, IEnumerable<T>?
                 return result;
             }
         }
+
+#if NETSTANDARD
+
+        // Copied from https://github.com/dotnet/runtime/blob/main/src/libraries/System.Linq/src/System/Linq/Chunk.cs
+        public static IEnumerable<TSource[]> Chunk<TSource>(this IEnumerable<TSource> source, int size)
+        {
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
+
+            if (size < 1)
+                throw new ArgumentOutOfRangeException(nameof(size));
+
+            if (source is TSource[] array)
+            {
+                // Special-case arrays, which have an immutable length. This enables us to not only do an
+                // empty check and avoid allocating an iterator object when empty, it enables us to have a
+                // much more efficient (and simpler) implementation for chunking up the array.
+                return array.Length != 0 ?
+                    ArrayChunkIterator(array, size) :
+                    [];
+            }
+
+            return EnumerableChunkIterator(source, size);
+        }
+
+        private static IEnumerable<TSource[]> ArrayChunkIterator<TSource>(TSource[] source, int size)
+        {
+            int index = 0;
+            while (index < source.Length)
+            {
+                TSource[] chunk = new ReadOnlySpan<TSource>(source, index, Math.Min(size, source.Length - index)).ToArray();
+                index += chunk.Length;
+                yield return chunk;
+            }
+        }
+
+        private static IEnumerable<TSource[]> EnumerableChunkIterator<TSource>(IEnumerable<TSource> source, int size)
+        {
+            using IEnumerator<TSource> e = source.GetEnumerator();
+
+            // Before allocating anything, make sure there's at least one element.
+            if (e.MoveNext())
+            {
+                // Now that we know we have at least one item, allocate an initial storage array. This is not
+                // the array we'll yield.  It starts out small in order to avoid significantly overallocating
+                // when the source has many fewer elements than the chunk size.
+                int arraySize = Math.Min(size, 4);
+                int i;
+                do
+                {
+                    var array = new TSource[arraySize];
+
+                    // Store the first item.
+                    array[0] = e.Current;
+                    i = 1;
+
+                    if (size != array.Length)
+                    {
+                        // This is the first chunk. As we fill the array, grow it as needed.
+                        for (; i < size && e.MoveNext(); i++)
+                        {
+                            if (i >= array.Length)
+                            {
+                                arraySize = (int)Math.Min((uint)size, 2 * (uint)array.Length);
+                                Array.Resize(ref array, arraySize);
+                            }
+
+                            array[i] = e.Current;
+                        }
+                    }
+                    else
+                    {
+                        // For all but the first chunk, the array will already be correctly sized.
+                        // We can just store into it until either it's full or MoveNext returns false.
+                        TSource[] local = array; // avoid bounds checks by using cached local (`array` is lifted to iterator object as a field)
+                        Debug.Assert(local.Length == size);
+                        for (; (uint)i < (uint)local.Length && e.MoveNext(); i++)
+                        {
+                            local[i] = e.Current;
+                        }
+                    }
+
+                    if (i != array.Length)
+                    {
+                        Array.Resize(ref array, i);
+                    }
+
+                    yield return array;
+                }
+                while (i >= size && e.MoveNext());
+            }
+        }
+
+#endif
     }
 }
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker.cs
index 9419df7c9703d..b70fd6bf67981 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker.cs
@@ -8,6 +8,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
@@ -321,9 +322,9 @@ InProgressState BuildInProgressStateFromNoCompilationState()
                         var translationActionsBuilder = ImmutableList.CreateBuilder<TranslationAction>();
 
                         var oldProjectState = initialProjectState;
-                        foreach (var documentState in this.ProjectState.DocumentStates.GetStatesInCompilationOrder())
+                        foreach (var chunk in this.ProjectState.DocumentStates.GetStatesInCompilationOrder().Chunk(TranslationAction.AddDocumentsAction.AddDocumentsBatchSize))
                         {
-                            var documentStates = ImmutableArray.Create(documentState);
+                            var documentStates = ImmutableCollectionsMarshal.AsImmutableArray(chunk);
                             var newProjectState = oldProjectState.AddDocuments(documentStates);
                             translationActionsBuilder.Add(new TranslationAction.AddDocumentsAction(
                                 oldProjectState, newProjectState, documentStates));
@@ -359,26 +360,6 @@ async Task<InProgressState> CollapseInProgressStateAsync(InProgressState initial
                     {
                         var currentState = initialState;
 
-                        // To speed things up, we look for all the added documents in the chain and we preemptively kick
-                        // off work to parse the documents for it in parallel.  This has the added benefit that if
-                        // someone asks for a frozen partial snapshot while we're in the middle of doing this, they can
-                        // use however many document states have successfully parsed their syntax trees.  For example,
-                        // if you had one extremely large file that took a long time to parse, and dozens of tiny ones,
-                        // it's more likely that the frozen tree would have many more documents in it.
-                        //
-                        // Note: we intentionally kick these off in a fire-and-forget fashion.  If we get canceled, all
-                        // the tasks will attempt to cancel.  If we complete, that's only because these tasks would
-                        // complete as well.  There's no need to track this with any sort of listener as this work just
-                        // acts to speed up getting to a compilation, but is otherwise unobservable.
-                        foreach (var action in currentState.PendingTranslationActions)
-                        {
-                            if (action is TranslationAction.AddDocumentsAction { Documents: var documents })
-                            {
-                                foreach (var document in documents)
-                                    _ = Task.Run(async () => await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false), cancellationToken);
-                            }
-                        }
-
                         // Then, we serially process the chain while that parsing is happening concurrently.
                         while (currentState.PendingTranslationActions.Count > 0)
                         {
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index 2582436c89b66..2ac4a04227178 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -126,17 +127,31 @@ internal sealed class AddDocumentsAction(
             ImmutableArray<DocumentState> documents)
             : TranslationAction(oldProjectState, newProjectState)
         {
+            /// <summary>
+            /// Amount to break batches of documents into.  That allows us to process things in parallel, without also
+            /// creating too many individual actions that then need to be processed.
+            /// </summary>
+            public const int AddDocumentsBatchSize = 128;
+
             public readonly ImmutableArray<DocumentState> Documents = documents;
 
             public override async Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
             {
-                // Parse all the documents in parallel.
-                using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(this.Documents.Length, out var tasks);
-                foreach (var document in this.Documents)
-                    tasks.Add(Task.Run(async () => await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false), cancellationToken));
+                // Parse all the documents in chunks in parallel.
+                using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(out var tasks);
+                var currentCompilation = oldCompilation;
+                foreach (var chunk in this.Documents.Chunk(AddDocumentsBatchSize))
+                {
+                    tasks.Clear();
+
+                    foreach (var document in chunk)
+                        tasks.Add(Task.Run(async () => await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false), cancellationToken));
+
+                    var trees = await Task.WhenAll(tasks).ConfigureAwait(false);
+                    currentCompilation = currentCompilation.AddSyntaxTrees(trees);
+                }
 
-                var trees = await Task.WhenAll(tasks).ConfigureAwait(false);
-                return oldCompilation.AddSyntaxTrees(trees);
+                return currentCompilation;
             }
 
             // This action adds the specified trees, but leaves the generated trees untouched.
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index 63c06209616af..10904b5373c28 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -9,6 +9,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Collections;
@@ -1353,28 +1354,52 @@ static SolutionCompilationState ComputeFrozenPartialState(
             CancellationToken cancellationToken)
         {
             var currentState = frozenCompilationState;
-            foreach (var newDocumentState in documentStates)
-            {
-                var documentId = newDocumentState.Id;
-                var oldProjectState = currentState.SolutionState.GetRequiredProjectState(documentId.ProjectId);
-                var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
 
-                if (oldDocumentState is null)
+            using var _ = PooledDictionary<ProjectState, ArrayBuilder<DocumentState>>.GetInstance(out var missingDocumentStates);
+            try
+            {
+                foreach (var newDocumentState in documentStates)
                 {
-                    // Project doesn't have this document, attempt to fork it with the document added.
-                    currentState = currentState.AddDocumentsToMultipleProjects(
-                        [(oldProjectState, [newDocumentState])],
-                        static (oldProjectState, newDocumentStates) =>
-                            new TranslationAction.AddDocumentsAction(oldProjectState, oldProjectState.AddDocuments(newDocumentStates), newDocumentStates));
+                    var documentId = newDocumentState.Id;
+                    var oldProjectState = currentState.SolutionState.GetRequiredProjectState(documentId.ProjectId);
+                    var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
+
+                    if (oldDocumentState is null)
+                    {
+                        if (!missingDocumentStates.TryGetValue(oldProjectState, out var projectDocumentStates))
+                        {
+                            projectDocumentStates = ArrayBuilder<DocumentState>.GetInstance();
+                            missingDocumentStates.Add(oldProjectState, projectDocumentStates);
+                        }
+
+                        projectDocumentStates.Add(newDocumentState);
+                    }
+                    else
+                    {
+                        // Project has this document, attempt to fork it with the new contents.
+                        currentState = currentState.WithDocumentState(newDocumentState);
+                    }
                 }
-                else
+
+                foreach (var (oldProjectState, projectDocumentStates) in missingDocumentStates)
                 {
-                    // Project has this document, attempt to fork it with the new contents.
-                    currentState = currentState.WithDocumentState(newDocumentState);
+                    foreach (var chunk in projectDocumentStates.Chunk(TranslationAction.AddDocumentsAction.AddDocumentsBatchSize))
+                    {
+                        var newDocumentStates = ImmutableCollectionsMarshal.AsImmutableArray(chunk);
+                        currentState = currentState.AddDocumentsToMultipleProjects(
+                            [(oldProjectState, newDocumentStates)],
+                            static (oldProjectState, newDocumentStates) =>
+                                new TranslationAction.AddDocumentsAction(oldProjectState, oldProjectState.AddDocuments(newDocumentStates), newDocumentStates));
+                    }
                 }
-            }
 
-            return currentState;
+                return currentState;
+            }
+            finally
+            {
+                foreach (var (_, arrayBuilder) in missingDocumentStates)
+                    arrayBuilder.Free();
+            }
         }
     }
 

From e93e02a40fbec9ced290899902f87132ba8cabce Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:01:20 -0700
Subject: [PATCH 141/170] Tweak

---
 ...tionCompilationState.CompilationTracker.cs | 10 ++--
 ...pilationState.TranslationAction_Actions.cs |  2 +-
 .../Solution/SolutionCompilationState.cs      | 57 ++++++++-----------
 3 files changed, 29 insertions(+), 40 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker.cs
index b70fd6bf67981..4134f3996f5ce 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.CompilationTracker.cs
@@ -311,11 +311,11 @@ InProgressState BuildInProgressStateFromNoCompilationState()
                 {
                     try
                     {
-                        // Create a chain of translation steps where we add each document one at a time to an initially
-                        // empty compilation.  This allows us to then process that chain of actions like we would do any
-                        // other.  It also means that if we're in the process of parsing documents in that chain, that
-                        // we'll see the results of how far we've gotten if someone asks for a frozen snapshot midway
-                        // through.
+                        // Create a chain of translation steps where we add a chunk of documents at a time to an
+                        // initially empty compilation.  This allows us to then process that chain of actions like we
+                        // would do any other.  It also means that if we're in the process of parsing documents in that
+                        // chain, that we'll see the results of how far we've gotten if someone asks for a frozen
+                        // snapshot midway through.
                         var initialProjectState = this.ProjectState.RemoveAllNormalDocuments();
                         var initialCompilation = this.CreateEmptyCompilation();
 
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index 2ac4a04227178..638b1367d0c45 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -137,7 +137,7 @@ internal sealed class AddDocumentsAction(
 
             public override async Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
             {
-                // Parse all the documents in chunks in parallel.
+                // Parallel parse the documents we have in chunks.
                 using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(out var tasks);
                 var currentCompilation = oldCompilation;
                 foreach (var chunk in this.Documents.Chunk(AddDocumentsBatchSize))
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index 10904b5373c28..3ebe8e61d3fb4 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -1356,50 +1356,39 @@ static SolutionCompilationState ComputeFrozenPartialState(
             var currentState = frozenCompilationState;
 
             using var _ = PooledDictionary<ProjectState, ArrayBuilder<DocumentState>>.GetInstance(out var missingDocumentStates);
-            try
-            {
-                foreach (var newDocumentState in documentStates)
-                {
-                    var documentId = newDocumentState.Id;
-                    var oldProjectState = currentState.SolutionState.GetRequiredProjectState(documentId.ProjectId);
-                    var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
 
-                    if (oldDocumentState is null)
-                    {
-                        if (!missingDocumentStates.TryGetValue(oldProjectState, out var projectDocumentStates))
-                        {
-                            projectDocumentStates = ArrayBuilder<DocumentState>.GetInstance();
-                            missingDocumentStates.Add(oldProjectState, projectDocumentStates);
-                        }
+            foreach (var newDocumentState in documentStates)
+            {
+                var documentId = newDocumentState.Id;
+                var oldProjectState = currentState.SolutionState.GetRequiredProjectState(documentId.ProjectId);
+                var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
 
-                        projectDocumentStates.Add(newDocumentState);
-                    }
-                    else
+                if (oldDocumentState is null)
+                {
+                    if (!missingDocumentStates.TryGetValue(oldProjectState, out var projectDocumentStates))
                     {
-                        // Project has this document, attempt to fork it with the new contents.
-                        currentState = currentState.WithDocumentState(newDocumentState);
+                        projectDocumentStates = ArrayBuilder<DocumentState>.GetInstance();
+                        missingDocumentStates.Add(oldProjectState, projectDocumentStates);
                     }
-                }
 
-                foreach (var (oldProjectState, projectDocumentStates) in missingDocumentStates)
+                    projectDocumentStates.Add(newDocumentState);
+                }
+                else
                 {
-                    foreach (var chunk in projectDocumentStates.Chunk(TranslationAction.AddDocumentsAction.AddDocumentsBatchSize))
-                    {
-                        var newDocumentStates = ImmutableCollectionsMarshal.AsImmutableArray(chunk);
-                        currentState = currentState.AddDocumentsToMultipleProjects(
-                            [(oldProjectState, newDocumentStates)],
-                            static (oldProjectState, newDocumentStates) =>
-                                new TranslationAction.AddDocumentsAction(oldProjectState, oldProjectState.AddDocuments(newDocumentStates), newDocumentStates));
-                    }
+                    // Project has this document, attempt to fork it with the new contents.
+                    currentState = currentState.WithDocumentState(newDocumentState);
                 }
-
-                return currentState;
             }
-            finally
+
+            foreach (var (oldProjectState, projectDocumentStates) in missingDocumentStates)
             {
-                foreach (var (_, arrayBuilder) in missingDocumentStates)
-                    arrayBuilder.Free();
+                currentState = currentState.AddDocumentsToMultipleProjects(
+                    [(oldProjectState, projectDocumentStates.ToImmutableAndFree())],
+                    static (oldProjectState, newDocumentStates) =>
+                        new TranslationAction.AddDocumentsAction(oldProjectState, oldProjectState.AddDocuments(newDocumentStates), newDocumentStates));
             }
+
+            return currentState;
         }
     }
 

From 563c543571cb5908ff2b4e6845d0e4a27ff6cc1f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:02:21 -0700
Subject: [PATCH 142/170] Lower batch size

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

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index 638b1367d0c45..976f5b20ed2c4 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -131,7 +131,7 @@ internal sealed class AddDocumentsAction(
             /// Amount to break batches of documents into.  That allows us to process things in parallel, without also
             /// creating too many individual actions that then need to be processed.
             /// </summary>
-            public const int AddDocumentsBatchSize = 128;
+            public const int AddDocumentsBatchSize = 32;
 
             public readonly ImmutableArray<DocumentState> Documents = documents;
 

From a5893b058dd0c046278950efdbed8c991255ea7b Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:04:14 -0700
Subject: [PATCH 143/170] Sort

---
 .../Core/Portable/InternalUtilities/EnumerableExtensions.cs  | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
index 089b100bb0fa0..0258d24e4c910 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
@@ -7,14 +7,13 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
-using System.Threading;
-using Microsoft.CodeAnalysis.Collections.Internal;
-using System.Diagnostics;
 
 #if DEBUG
 using System.Diagnostics;

From b337107bdc015626a1658f745261be61e460937e Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:06:13 -0700
Subject: [PATCH 144/170] Add initial size

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

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index 976f5b20ed2c4..fbc17f98aa043 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -138,7 +138,7 @@ internal sealed class AddDocumentsAction(
             public override async Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
             {
                 // Parallel parse the documents we have in chunks.
-                using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(out var tasks);
+                using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(AddDocumentsBatchSize, out var tasks);
                 var currentCompilation = oldCompilation;
                 foreach (var chunk in this.Documents.Chunk(AddDocumentsBatchSize))
                 {

From b9d81aea90a5e512f8dc87cea93b4f3435751be0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:08:27 -0700
Subject: [PATCH 145/170] Fix

---
 .../Solution/SolutionCompilationState.cs       | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index 3ebe8e61d3fb4..da0518b78b9d4 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -1355,6 +1355,18 @@ static SolutionCompilationState ComputeFrozenPartialState(
         {
             var currentState = frozenCompilationState;
 
+            // First, add in all the changed documents.
+            foreach (var newDocumentState in documentStates)
+            {
+                var documentId = newDocumentState.Id;
+                var oldProjectState = currentState.SolutionState.GetRequiredProjectState(documentId.ProjectId);
+                var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
+
+                if (oldDocumentState is not null)
+                    currentState = currentState.WithDocumentState(newDocumentState);
+            }
+
+            // Then find and group all missing documents.
             using var _ = PooledDictionary<ProjectState, ArrayBuilder<DocumentState>>.GetInstance(out var missingDocumentStates);
 
             foreach (var newDocumentState in documentStates)
@@ -1373,13 +1385,9 @@ static SolutionCompilationState ComputeFrozenPartialState(
 
                     projectDocumentStates.Add(newDocumentState);
                 }
-                else
-                {
-                    // Project has this document, attempt to fork it with the new contents.
-                    currentState = currentState.WithDocumentState(newDocumentState);
-                }
             }
 
+            // Now, add all missing documents per project.
             foreach (var (oldProjectState, projectDocumentStates) in missingDocumentStates)
             {
                 currentState = currentState.AddDocumentsToMultipleProjects(

From da8aa515e9521e263e9d980d73acfa7068196790 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:09:33 -0700
Subject: [PATCH 146/170] Simplify

---
 .../Workspace/Solution/SolutionCompilationState.cs     | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index da0518b78b9d4..f7f46f7658a4f 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -1376,15 +1376,7 @@ static SolutionCompilationState ComputeFrozenPartialState(
                 var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
 
                 if (oldDocumentState is null)
-                {
-                    if (!missingDocumentStates.TryGetValue(oldProjectState, out var projectDocumentStates))
-                    {
-                        projectDocumentStates = ArrayBuilder<DocumentState>.GetInstance();
-                        missingDocumentStates.Add(oldProjectState, projectDocumentStates);
-                    }
-
-                    projectDocumentStates.Add(newDocumentState);
-                }
+                    missingDocumentStates.MultiAdd(oldProjectState, newDocumentState);
             }
 
             // Now, add all missing documents per project.

From ab3090d15ae8856a651b0c72fc132c693c41e287 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:23:18 -0700
Subject: [PATCH 147/170] remove chunking

---
 ...lutionCompilationState.TranslationAction_Actions.cs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index fbc17f98aa043..bdf48e3f4fed2 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
@@ -140,12 +141,17 @@ public override async Task<Compilation> TransformCompilationAsync(Compilation ol
                 // Parallel parse the documents we have in chunks.
                 using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(AddDocumentsBatchSize, out var tasks);
                 var currentCompilation = oldCompilation;
-                foreach (var chunk in this.Documents.Chunk(AddDocumentsBatchSize))
+
+                for (int i = 0, n = this.Documents.Length; i < n; i += AddDocumentsBatchSize)
                 {
                     tasks.Clear();
 
-                    foreach (var document in chunk)
+                    var batchEnd = Math.Min(i + AddDocumentsBatchSize, n);
+                    for (var j = i; j < batchEnd; j++)
+                    {
+                        var document = this.Documents[j];
                         tasks.Add(Task.Run(async () => await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false), cancellationToken));
+                    }
 
                     var trees = await Task.WhenAll(tasks).ConfigureAwait(false);
                     currentCompilation = currentCompilation.AddSyntaxTrees(trees);

From 934f465efd6c8d479f9b8b129f0b919e8ad70dd4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:36:37 -0700
Subject: [PATCH 148/170] rename

---
 .../SolutionCompilationState.TranslationAction_Actions.cs  | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index bdf48e3f4fed2..77c8bac5ab6e5 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -142,14 +142,13 @@ public override async Task<Compilation> TransformCompilationAsync(Compilation ol
                 using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(AddDocumentsBatchSize, out var tasks);
                 var currentCompilation = oldCompilation;
 
-                for (int i = 0, n = this.Documents.Length; i < n; i += AddDocumentsBatchSize)
+                for (int batchStart = 0, total = this.Documents.Length; batchStart < total; batchStart += AddDocumentsBatchSize)
                 {
                     tasks.Clear();
 
-                    var batchEnd = Math.Min(i + AddDocumentsBatchSize, n);
-                    for (var j = i; j < batchEnd; j++)
+                    for (int i = batchStart, batchEnd = Math.Min(batchStart + AddDocumentsBatchSize, total); i < batchEnd; i++)
                     {
-                        var document = this.Documents[j];
+                        var document = this.Documents[i];
                         tasks.Add(Task.Run(async () => await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false), cancellationToken));
                     }
 

From a70d0ff77a3d07e1e81d891657a48c0adcac770b Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:39:59 -0700
Subject: [PATCH 149/170] Clean

---
 .../Core/Portable/Workspace/Solution/SolutionCompilationState.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index f7f46f7658a4f..6f9ec72acc809 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -9,7 +9,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Collections;

From 02905f2206f90dd7713c4ca83c939bc5128d7c66 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:42:14 -0700
Subject: [PATCH 150/170] Simplify

---
 .../Solution/SolutionCompilationState.cs      | 26 ++++++++-----------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index 6f9ec72acc809..2d160ac6f64d4 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -1354,7 +1354,9 @@ static SolutionCompilationState ComputeFrozenPartialState(
         {
             var currentState = frozenCompilationState;
 
-            // First, add in all the changed documents.
+            using var _ = PooledDictionary<ProjectId, ArrayBuilder<DocumentState>>.GetInstance(out var missingDocumentStates);
+
+            // First, either update documents that have changed, or keep track of documents that are missing.
             foreach (var newDocumentState in documentStates)
             {
                 var documentId = newDocumentState.Id;
@@ -1362,25 +1364,19 @@ static SolutionCompilationState ComputeFrozenPartialState(
                 var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
 
                 if (oldDocumentState is not null)
+                {
                     currentState = currentState.WithDocumentState(newDocumentState);
-            }
-
-            // Then find and group all missing documents.
-            using var _ = PooledDictionary<ProjectState, ArrayBuilder<DocumentState>>.GetInstance(out var missingDocumentStates);
-
-            foreach (var newDocumentState in documentStates)
-            {
-                var documentId = newDocumentState.Id;
-                var oldProjectState = currentState.SolutionState.GetRequiredProjectState(documentId.ProjectId);
-                var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
-
-                if (oldDocumentState is null)
-                    missingDocumentStates.MultiAdd(oldProjectState, newDocumentState);
+                }
+                else
+                {
+                    missingDocumentStates.MultiAdd(documentId.ProjectId, newDocumentState);
+                }
             }
 
             // Now, add all missing documents per project.
-            foreach (var (oldProjectState, projectDocumentStates) in missingDocumentStates)
+            foreach (var (projectId, projectDocumentStates) in missingDocumentStates)
             {
+                var oldProjectState = currentState.SolutionState.GetRequiredProjectState(projectId);
                 currentState = currentState.AddDocumentsToMultipleProjects(
                     [(oldProjectState, projectDocumentStates.ToImmutableAndFree())],
                     static (oldProjectState, newDocumentStates) =>

From c9ef99e7826b88bedd0bc2bc98540a944331196f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:43:27 -0700
Subject: [PATCH 151/170] Docs

---
 .../SolutionCompilationState.TranslationAction_Actions.cs        | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index 77c8bac5ab6e5..e4bdf7418da09 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -142,6 +142,7 @@ public override async Task<Compilation> TransformCompilationAsync(Compilation ol
                 using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(AddDocumentsBatchSize, out var tasks);
                 var currentCompilation = oldCompilation;
 
+                // Can simplify this to use span-slicing once the language supports using ref-structs in async methods.
                 for (int batchStart = 0, total = this.Documents.Length; batchStart < total; batchStart += AddDocumentsBatchSize)
                 {
                     tasks.Clear();

From 1dfd632128019254ed4c1a6db26b5d3d72890753 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:47:59 -0700
Subject: [PATCH 152/170] Docs

---
 .../Workspace/Solution/SolutionCompilationState.cs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index 2d160ac6f64d4..77ebc0a917775 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -1374,14 +1374,12 @@ static SolutionCompilationState ComputeFrozenPartialState(
             }
 
             // Now, add all missing documents per project.
-            foreach (var (projectId, projectDocumentStates) in missingDocumentStates)
-            {
-                var oldProjectState = currentState.SolutionState.GetRequiredProjectState(projectId);
-                currentState = currentState.AddDocumentsToMultipleProjects(
-                    [(oldProjectState, projectDocumentStates.ToImmutableAndFree())],
-                    static (oldProjectState, newDocumentStates) =>
-                        new TranslationAction.AddDocumentsAction(oldProjectState, oldProjectState.AddDocuments(newDocumentStates), newDocumentStates));
-            }
+            currentState = currentState.AddDocumentsToMultipleProjects(
+                // Do a SelectAsArray here to ensure that we realize the array once, and as such only call things like
+                // ToImmutableAndClear once per ArrayBuilder.
+                missingDocumentStates.SelectAsArray(kvp => (currentState.SolutionState.GetRequiredProjectState(kvp.Key), kvp.Value.ToImmutableAndClear())),
+                static (oldProjectState, newDocumentStates) =>
+                    new TranslationAction.AddDocumentsAction(oldProjectState, oldProjectState.AddDocuments(newDocumentStates), newDocumentStates));
 
             return currentState;
         }

From 660af5d15b778eae8699c931cdbc36434ea9363c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:50:30 -0700
Subject: [PATCH 153/170] Free

---
 .../Portable/Workspace/Solution/SolutionCompilationState.cs   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index 77ebc0a917775..cdd3bd07e416d 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -1376,8 +1376,8 @@ static SolutionCompilationState ComputeFrozenPartialState(
             // Now, add all missing documents per project.
             currentState = currentState.AddDocumentsToMultipleProjects(
                 // Do a SelectAsArray here to ensure that we realize the array once, and as such only call things like
-                // ToImmutableAndClear once per ArrayBuilder.
-                missingDocumentStates.SelectAsArray(kvp => (currentState.SolutionState.GetRequiredProjectState(kvp.Key), kvp.Value.ToImmutableAndClear())),
+                // ToImmutableAndFree once per ArrayBuilder.
+                missingDocumentStates.SelectAsArray(kvp => (currentState.SolutionState.GetRequiredProjectState(kvp.Key), kvp.Value.ToImmutableAndFree())),
                 static (oldProjectState, newDocumentStates) =>
                     new TranslationAction.AddDocumentsAction(oldProjectState, oldProjectState.AddDocuments(newDocumentStates), newDocumentStates));
 

From 519d839503a64374b8f513ed36c609d8f98f3653 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:53:14 -0700
Subject: [PATCH 154/170] Simplify

---
 .../Workspace/Solution/SolutionCompilationState.cs       | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index cdd3bd07e416d..83bd267f7a6c6 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -1377,7 +1377,7 @@ static SolutionCompilationState ComputeFrozenPartialState(
             currentState = currentState.AddDocumentsToMultipleProjects(
                 // Do a SelectAsArray here to ensure that we realize the array once, and as such only call things like
                 // ToImmutableAndFree once per ArrayBuilder.
-                missingDocumentStates.SelectAsArray(kvp => (currentState.SolutionState.GetRequiredProjectState(kvp.Key), kvp.Value.ToImmutableAndFree())),
+                missingDocumentStates.SelectAsArray(kvp => (kvp.Key, kvp.Value.ToImmutableAndFree())),
                 static (oldProjectState, newDocumentStates) =>
                     new TranslationAction.AddDocumentsAction(oldProjectState, oldProjectState.AddDocuments(newDocumentStates), newDocumentStates));
 
@@ -1454,20 +1454,21 @@ private SolutionCompilationState AddDocumentsToMultipleProjects<TDocumentState>(
                 var projectId = g.Key;
                 this.SolutionState.CheckContainsProject(projectId);
                 var projectState = this.SolutionState.GetRequiredProjectState(projectId);
-                return (projectState, newDocumentStates: g.SelectAsArray(di => createDocumentState(di, projectState)));
+                return (projectId, newDocumentStates: g.SelectAsArray(di => createDocumentState(di, projectState)));
             }),
             addDocumentsToProjectState);
     }
 
     private SolutionCompilationState AddDocumentsToMultipleProjects<TDocumentState>(
-        IEnumerable<(ProjectState oldProjectState, ImmutableArray<TDocumentState> newDocumentStates)> projectIdAndNewDocuments,
+        IEnumerable<(ProjectId projectId, ImmutableArray<TDocumentState> newDocumentStates)> projectIdAndNewDocuments,
         Func<ProjectState, ImmutableArray<TDocumentState>, TranslationAction> addDocumentsToProjectState)
         where TDocumentState : TextDocumentState
     {
         var newCompilationState = this;
 
-        foreach (var (oldProjectState, newDocumentStates) in projectIdAndNewDocuments)
+        foreach (var (projectId, newDocumentStates) in projectIdAndNewDocuments)
         {
+            var oldProjectState = newCompilationState.SolutionState.GetRequiredProjectState(projectId);
             var compilationTranslationAction = addDocumentsToProjectState(oldProjectState, newDocumentStates);
             var newProjectState = compilationTranslationAction.NewProjectState;
 

From 880272712f5e0a97b44f19ba118a06ddce0f5255 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 12:58:58 -0700
Subject: [PATCH 155/170] Invert if

---
 .../Portable/Workspace/Solution/SolutionCompilationState.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
index 83bd267f7a6c6..8fae3dc62d07b 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.cs
@@ -1363,13 +1363,13 @@ static SolutionCompilationState ComputeFrozenPartialState(
                 var oldProjectState = currentState.SolutionState.GetRequiredProjectState(documentId.ProjectId);
                 var oldDocumentState = oldProjectState.DocumentStates.GetState(documentId);
 
-                if (oldDocumentState is not null)
+                if (oldDocumentState is null)
                 {
-                    currentState = currentState.WithDocumentState(newDocumentState);
+                    missingDocumentStates.MultiAdd(documentId.ProjectId, newDocumentState);
                 }
                 else
                 {
-                    missingDocumentStates.MultiAdd(documentId.ProjectId, newDocumentState);
+                    currentState = currentState.WithDocumentState(newDocumentState);
                 }
             }
 

From 452661afec0024ead273db5a1541c3f28265e73f Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Wed, 20 Mar 2024 13:56:45 -0700
Subject: [PATCH 156/170] Lint

---
 .../Core/Portable/InternalUtilities/EnumerableExtensions.cs      | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
index 0258d24e4c910..222825fba54f2 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
@@ -7,7 +7,6 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Collections.ObjectModel;
-using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;

From 8bbc1b729cf731ec47480cec696a1461ae8b4eb4 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Wed, 20 Mar 2024 14:09:25 -0700
Subject: [PATCH 157/170] fix

---
 .../Core/Portable/InternalUtilities/EnumerableExtensions.cs  | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
index 222825fba54f2..b299b637fc11a 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,10 +15,6 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
-#if DEBUG
-using System.Diagnostics;
-#endif
-
 namespace Roslyn.Utilities
 {
     internal static partial class EnumerableExtensions

From 9aea13f1d7681e2f4216a65b8158dc6c2b16c8ab Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmabadi@gmail.com>
Date: Wed, 20 Mar 2024 15:16:52 -0700
Subject: [PATCH 158/170] Fix excessive compilation times due to speculative
 parsing after an incomplete string (#72565)

---
 .../CSharp/Portable/Parser/LanguageParser.cs  |  54 +-
 .../CollectionExpressionParsingTests.cs       | 984 ++++++++++++++++++
 2 files changed, 1035 insertions(+), 3 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
index 830d75daae40f..007aab4bc1859 100644
--- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
+++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs
@@ -1040,6 +1040,7 @@ private AttributeSyntax ParseAttribute()
                 SyntaxKind.CloseParenToken,
                 static @this => @this.IsPossibleAttributeArgument(),
                 static @this => @this.ParseAttributeArgument(),
+                immediatelyAbort,
                 skipBadAttributeArgumentTokens,
                 allowTrailingSeparator: false,
                 requireOneElement: false,
@@ -1058,6 +1059,23 @@ static PostSkipAction skipBadAttributeArgumentTokens(
                     static (p, closeKind) => p.CurrentToken.Kind == closeKind,
                     expectedKind, closeKind);
             }
+
+            static bool immediatelyAbort(AttributeArgumentSyntax argument)
+            {
+                // We can be very thrown off by incomplete strings in an attribute argument (especially as the lexer
+                // will restart on the next line with the contents of the string then being interpreted as more
+                // arguments).  Bail out in this case to prevent going off the rails.
+                if (argument.expression is LiteralExpressionSyntax { Kind: SyntaxKind.StringLiteralExpression, Token: var literalToken } &&
+                    literalToken.GetDiagnostics().Contains(d => d.Code == (int)ErrorCode.ERR_NewlineInConst))
+                {
+                    return true;
+                }
+
+                if (argument.expression is InterpolatedStringExpressionSyntax { StringStartToken.Kind: SyntaxKind.InterpolatedStringStartToken, StringEndToken.IsMissing: true })
+                    return true;
+
+                return false;
+            }
         }
 
         private bool IsPossibleAttributeArgument()
@@ -13321,6 +13339,8 @@ private bool IsInQuery
         private delegate PostSkipAction SkipBadTokens<TNode>(
             LanguageParser parser, ref SyntaxToken openToken, SeparatedSyntaxListBuilder<TNode> builder, SyntaxKind expectedKind, SyntaxKind closeTokenKind) where TNode : GreenNode;
 
+#nullable enable
+
         /// <summary>
         /// Parses a comma separated list of nodes.
         /// </summary>
@@ -13357,6 +13377,29 @@ private SeparatedSyntaxList<TNode> ParseCommaSeparatedSyntaxList<TNode>(
             bool allowTrailingSeparator,
             bool requireOneElement,
             bool allowSemicolonAsSeparator) where TNode : GreenNode
+        {
+            return ParseCommaSeparatedSyntaxList(
+                ref openToken,
+                closeTokenKind,
+                isPossibleElement,
+                parseElement,
+                immediatelyAbort: null,
+                skipBadTokens,
+                allowTrailingSeparator,
+                requireOneElement,
+                allowSemicolonAsSeparator);
+        }
+
+        private SeparatedSyntaxList<TNode> ParseCommaSeparatedSyntaxList<TNode>(
+            ref SyntaxToken openToken,
+            SyntaxKind closeTokenKind,
+            Func<LanguageParser, bool> isPossibleElement,
+            Func<LanguageParser, TNode> parseElement,
+            Func<TNode, bool>? immediatelyAbort,
+            SkipBadTokens<TNode> skipBadTokens,
+            bool allowTrailingSeparator,
+            bool requireOneElement,
+            bool allowSemicolonAsSeparator) where TNode : GreenNode
         {
             // If we ever want this function to parse out separated lists with a different separator, we can
             // parameterize this method on this value.
@@ -13369,7 +13412,8 @@ private SeparatedSyntaxList<TNode> ParseCommaSeparatedSyntaxList<TNode>(
                 if (requireOneElement || shouldParseSeparatorOrElement())
                 {
                     // first argument
-                    nodes.Add(parseElement(this));
+                    var node = parseElement(this);
+                    nodes.Add(node);
 
                     // now that we've gotten one element, we don't require any more.
                     requireOneElement = false;
@@ -13377,7 +13421,8 @@ private SeparatedSyntaxList<TNode> ParseCommaSeparatedSyntaxList<TNode>(
                     // Ensure that if parsing separators/elements doesn't move us forward, that we always bail out from
                     // parsing this list.
                     int lastTokenPosition = -1;
-                    while (IsMakingProgress(ref lastTokenPosition))
+
+                    while (immediatelyAbort?.Invoke(node) != true && IsMakingProgress(ref lastTokenPosition))
                     {
                         if (this.CurrentToken.Kind == closeTokenKind)
                             break;
@@ -13402,7 +13447,8 @@ private SeparatedSyntaxList<TNode> ParseCommaSeparatedSyntaxList<TNode>(
                                 }
                             }
 
-                            nodes.Add(parseElement(this));
+                            node = parseElement(this);
+                            nodes.Add(node);
                             continue;
                         }
 
@@ -13441,6 +13487,8 @@ bool shouldParseSeparatorOrElement()
             }
         }
 
+#nullable disable
+
         private DisposableResetPoint GetDisposableResetPoint(bool resetOnDispose)
             => new DisposableResetPoint(this, resetOnDispose, GetResetPoint());
 
diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/CollectionExpressionParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/CollectionExpressionParsingTests.cs
index 75cde7ce70fbc..5eed36571065c 100644
--- a/src/Compilers/CSharp/Test/Syntax/Parsing/CollectionExpressionParsingTests.cs
+++ b/src/Compilers/CSharp/Test/Syntax/Parsing/CollectionExpressionParsingTests.cs
@@ -17128,4 +17128,988 @@ public void CollectionExpressionParsingSlotCounts([CombinatorialRange(1, 20)] in
         N(SyntaxKind.CloseBracketToken);
         EOF();
     }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/72557")]
+    public void TestIncompleteString1()
+    {
+        UsingTree("""
+            public enum BundleType
+            {
+                [A("B", "C"), Description("Goo
+                bar baz")]
+                A,
+                [A("B", "C"), Description("Goo
+                bar baz")]
+                B,
+            }
+            """,
+            // (3,31): error CS1010: Newline in constant
+            //     [A("B", "C"), Description("Goo
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(3, 31),
+            // (3,35): error CS1026: ) expected
+            //     [A("B", "C"), Description("Goo
+            Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(3, 35),
+            // (3,35): error CS1003: Syntax error, ',' expected
+            //     [A("B", "C"), Description("Goo
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(3, 35),
+            // (4,9): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "baz").WithArguments(",").WithLocation(4, 9),
+            // (4,12): error CS1010: Newline in constant
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(4, 12),
+            // (4,15): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(4, 15),
+            // (5,7): error CS1003: Syntax error, ']' expected
+            //     A,
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(5, 7),
+            // (6,31): error CS1010: Newline in constant
+            //     [A("B", "C"), Description("Goo
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(6, 31),
+            // (6,35): error CS1026: ) expected
+            //     [A("B", "C"), Description("Goo
+            Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(6, 35),
+            // (6,35): error CS1003: Syntax error, ',' expected
+            //     [A("B", "C"), Description("Goo
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(6, 35),
+            // (7,9): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "baz").WithArguments(",").WithLocation(7, 9),
+            // (7,12): error CS1010: Newline in constant
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(7, 12),
+            // (7,15): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(7, 15),
+            // (8,7): error CS1003: Syntax error, ']' expected
+            //     B,
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(8, 7),
+            // (8,7): error CS1001: Identifier expected
+            //     B,
+            Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(8, 7));
+
+        N(SyntaxKind.CompilationUnit);
+        {
+            N(SyntaxKind.EnumDeclaration);
+            {
+                N(SyntaxKind.PublicKeyword);
+                N(SyntaxKind.EnumKeyword);
+                N(SyntaxKind.IdentifierToken, "BundleType");
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.EnumMemberDeclaration);
+                {
+                    N(SyntaxKind.AttributeList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"B\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"C\"");
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Description");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"Goo");
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "bar");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "baz");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.CloseBracketToken);
+                    }
+                    N(SyntaxKind.AttributeList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"B\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"C\"");
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Description");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"Goo");
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "bar");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "baz");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "B");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.CloseBracketToken);
+                    }
+                    M(SyntaxKind.IdentifierToken);
+                }
+                N(SyntaxKind.CloseBraceToken);
+            }
+            N(SyntaxKind.EndOfFileToken);
+        }
+        EOF();
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/72557")]
+    public void TestIncompleteString2()
+    {
+        UsingTree("""
+            public enum BundleType
+            {
+                [A("B", "C"), Description("X", "Goo
+                bar baz")]
+                A,
+                [A("B", "C"), Description("X", "Goo
+                bar baz")]
+                B,
+            }
+            """,
+            // (3,36): error CS1010: Newline in constant
+            //     [A("B", "C"), Description("X", "Goo
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(3, 36),
+            // (3,40): error CS1026: ) expected
+            //     [A("B", "C"), Description("X", "Goo
+            Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(3, 40),
+            // (3,40): error CS1003: Syntax error, ',' expected
+            //     [A("B", "C"), Description("X", "Goo
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(3, 40),
+            // (4,9): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "baz").WithArguments(",").WithLocation(4, 9),
+            // (4,12): error CS1010: Newline in constant
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(4, 12),
+            // (4,15): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(4, 15),
+            // (5,7): error CS1003: Syntax error, ']' expected
+            //     A,
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(5, 7),
+            // (6,36): error CS1010: Newline in constant
+            //     [A("B", "C"), Description("X", "Goo
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(6, 36),
+            // (6,40): error CS1026: ) expected
+            //     [A("B", "C"), Description("X", "Goo
+            Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(6, 40),
+            // (6,40): error CS1003: Syntax error, ',' expected
+            //     [A("B", "C"), Description("X", "Goo
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(6, 40),
+            // (7,9): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "baz").WithArguments(",").WithLocation(7, 9),
+            // (7,12): error CS1010: Newline in constant
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(7, 12),
+            // (7,15): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(7, 15),
+            // (8,7): error CS1003: Syntax error, ']' expected
+            //     B,
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(8, 7),
+            // (8,7): error CS1001: Identifier expected
+            //     B,
+            Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(8, 7));
+
+        N(SyntaxKind.CompilationUnit);
+        {
+            N(SyntaxKind.EnumDeclaration);
+            {
+                N(SyntaxKind.PublicKeyword);
+                N(SyntaxKind.EnumKeyword);
+                N(SyntaxKind.IdentifierToken, "BundleType");
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.EnumMemberDeclaration);
+                {
+                    N(SyntaxKind.AttributeList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"B\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"C\"");
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Description");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"X\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"Goo");
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "bar");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "baz");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.CloseBracketToken);
+                    }
+                    N(SyntaxKind.AttributeList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"B\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"C\"");
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Description");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"X\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"Goo");
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "bar");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "baz");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "B");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.CloseBracketToken);
+                    }
+                    M(SyntaxKind.IdentifierToken);
+                }
+                N(SyntaxKind.CloseBraceToken);
+            }
+            N(SyntaxKind.EndOfFileToken);
+        }
+        EOF();
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/72557")]
+    public void TestIncompleteString3()
+    {
+        UsingTree("""
+            public enum BundleType
+            {
+                [A("B", "C"), Description($"Goo
+                bar baz")]
+                A,
+                [A("B", "C"), Description($"Goo
+                bar baz")]
+                B,
+            }
+            """,
+            // (3,35): error CS1039: Unterminated string literal
+            //     [A("B", "C"), Description($"Goo
+            Diagnostic(ErrorCode.ERR_UnterminatedStringLit, "o").WithLocation(3, 35),
+            // (3,36): error CS1026: ) expected
+            //     [A("B", "C"), Description($"Goo
+            Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(3, 36),
+            // (3,36): error CS1003: Syntax error, ',' expected
+            //     [A("B", "C"), Description($"Goo
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(3, 36),
+            // (4,9): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "baz").WithArguments(",").WithLocation(4, 9),
+            // (4,12): error CS1010: Newline in constant
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(4, 12),
+            // (4,15): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(4, 15),
+            // (5,7): error CS1003: Syntax error, ']' expected
+            //     A,
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(5, 7),
+            // (6,35): error CS1039: Unterminated string literal
+            //     [A("B", "C"), Description($"Goo
+            Diagnostic(ErrorCode.ERR_UnterminatedStringLit, "o").WithLocation(6, 35),
+            // (6,36): error CS1026: ) expected
+            //     [A("B", "C"), Description($"Goo
+            Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(6, 36),
+            // (6,36): error CS1003: Syntax error, ',' expected
+            //     [A("B", "C"), Description($"Goo
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(6, 36),
+            // (7,9): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "baz").WithArguments(",").WithLocation(7, 9),
+            // (7,12): error CS1010: Newline in constant
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(7, 12),
+            // (7,15): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(7, 15),
+            // (8,7): error CS1003: Syntax error, ']' expected
+            //     B,
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(8, 7),
+            // (8,7): error CS1001: Identifier expected
+            //     B,
+            Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(8, 7));
+
+        N(SyntaxKind.CompilationUnit);
+        {
+            N(SyntaxKind.EnumDeclaration);
+            {
+                N(SyntaxKind.PublicKeyword);
+                N(SyntaxKind.EnumKeyword);
+                N(SyntaxKind.IdentifierToken, "BundleType");
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.EnumMemberDeclaration);
+                {
+                    N(SyntaxKind.AttributeList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"B\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"C\"");
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Description");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.InterpolatedStringExpression);
+                                    {
+                                        N(SyntaxKind.InterpolatedStringStartToken);
+                                        N(SyntaxKind.InterpolatedStringText);
+                                        {
+                                            N(SyntaxKind.InterpolatedStringTextToken);
+                                        }
+                                        M(SyntaxKind.InterpolatedStringEndToken);
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "bar");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "baz");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.CloseBracketToken);
+                    }
+                    N(SyntaxKind.AttributeList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"B\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"C\"");
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Description");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.InterpolatedStringExpression);
+                                    {
+                                        N(SyntaxKind.InterpolatedStringStartToken);
+                                        N(SyntaxKind.InterpolatedStringText);
+                                        {
+                                            N(SyntaxKind.InterpolatedStringTextToken);
+                                        }
+                                        M(SyntaxKind.InterpolatedStringEndToken);
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "bar");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "baz");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "B");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.CloseBracketToken);
+                    }
+                    M(SyntaxKind.IdentifierToken);
+                }
+                N(SyntaxKind.CloseBraceToken);
+            }
+            N(SyntaxKind.EndOfFileToken);
+        }
+        EOF();
+    }
+
+    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/72557")]
+    public void TestIncompleteString4()
+    {
+        UsingTree("""
+            public enum BundleType
+            {
+                [A("B", "C"), Description("X", $"Goo
+                bar baz")]
+                A,
+                [A("B", "C"), Description("X", $"Goo
+                bar baz")]
+                B,
+            }
+            """,
+            // (3,40): error CS1039: Unterminated string literal
+            //     [A("B", "C"), Description("X", $"Goo
+            Diagnostic(ErrorCode.ERR_UnterminatedStringLit, "o").WithLocation(3, 40),
+            // (3,41): error CS1026: ) expected
+            //     [A("B", "C"), Description("X", $"Goo
+            Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(3, 41),
+            // (3,41): error CS1003: Syntax error, ',' expected
+            //     [A("B", "C"), Description("X", $"Goo
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(3, 41),
+            // (4,9): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "baz").WithArguments(",").WithLocation(4, 9),
+            // (4,12): error CS1010: Newline in constant
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(4, 12),
+            // (4,15): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(4, 15),
+            // (5,7): error CS1003: Syntax error, ']' expected
+            //     A,
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(5, 7),
+            // (6,40): error CS1039: Unterminated string literal
+            //     [A("B", "C"), Description("X", $"Goo
+            Diagnostic(ErrorCode.ERR_UnterminatedStringLit, "o").WithLocation(6, 40),
+            // (6,41): error CS1026: ) expected
+            //     [A("B", "C"), Description("X", $"Goo
+            Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(6, 41),
+            // (6,41): error CS1003: Syntax error, ',' expected
+            //     [A("B", "C"), Description("X", $"Goo
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(6, 41),
+            // (7,9): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "baz").WithArguments(",").WithLocation(7, 9),
+            // (7,12): error CS1010: Newline in constant
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_NewlineInConst, "").WithLocation(7, 12),
+            // (7,15): error CS1003: Syntax error, ',' expected
+            //     bar baz")]
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(",").WithLocation(7, 15),
+            // (8,7): error CS1003: Syntax error, ']' expected
+            //     B,
+            Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(8, 7),
+            // (8,7): error CS1001: Identifier expected
+            //     B,
+            Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(8, 7));
+
+        N(SyntaxKind.CompilationUnit);
+        {
+            N(SyntaxKind.EnumDeclaration);
+            {
+                N(SyntaxKind.PublicKeyword);
+                N(SyntaxKind.EnumKeyword);
+                N(SyntaxKind.IdentifierToken, "BundleType");
+                N(SyntaxKind.OpenBraceToken);
+                N(SyntaxKind.EnumMemberDeclaration);
+                {
+                    N(SyntaxKind.AttributeList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"B\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"C\"");
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Description");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"X\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.InterpolatedStringExpression);
+                                    {
+                                        N(SyntaxKind.InterpolatedStringStartToken);
+                                        N(SyntaxKind.InterpolatedStringText);
+                                        {
+                                            N(SyntaxKind.InterpolatedStringTextToken);
+                                        }
+                                        M(SyntaxKind.InterpolatedStringEndToken);
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "bar");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "baz");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.CloseBracketToken);
+                    }
+                    N(SyntaxKind.AttributeList);
+                    {
+                        N(SyntaxKind.OpenBracketToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "A");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"B\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"C\"");
+                                    }
+                                }
+                                N(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "Description");
+                            }
+                            N(SyntaxKind.AttributeArgumentList);
+                            {
+                                N(SyntaxKind.OpenParenToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.StringLiteralExpression);
+                                    {
+                                        N(SyntaxKind.StringLiteralToken, "\"X\"");
+                                    }
+                                }
+                                N(SyntaxKind.CommaToken);
+                                N(SyntaxKind.AttributeArgument);
+                                {
+                                    N(SyntaxKind.InterpolatedStringExpression);
+                                    {
+                                        N(SyntaxKind.InterpolatedStringStartToken);
+                                        N(SyntaxKind.InterpolatedStringText);
+                                        {
+                                            N(SyntaxKind.InterpolatedStringTextToken);
+                                        }
+                                        M(SyntaxKind.InterpolatedStringEndToken);
+                                    }
+                                }
+                                M(SyntaxKind.CloseParenToken);
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "bar");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "baz");
+                            }
+                        }
+                        M(SyntaxKind.CommaToken);
+                        N(SyntaxKind.Attribute);
+                        {
+                            N(SyntaxKind.IdentifierName);
+                            {
+                                N(SyntaxKind.IdentifierToken, "B");
+                            }
+                        }
+                        N(SyntaxKind.CommaToken);
+                        M(SyntaxKind.CloseBracketToken);
+                    }
+                    M(SyntaxKind.IdentifierToken);
+                }
+                N(SyntaxKind.CloseBraceToken);
+            }
+            N(SyntaxKind.EndOfFileToken);
+        }
+        EOF();
+    }
 }

From a66551a8b47f5c68a36e3fc780237a9916e49337 Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Wed, 20 Mar 2024 16:58:28 -0700
Subject: [PATCH 159/170] Pass the temp path to DesktopStrongNameProvider ctor
 (#72587)

This addresses feedback ticket: https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1950505

The underlying issue here is that the DesktopStrongNameProvider assumes it's caller will pass it a temp directory as EmitStream.CreateStream fails if the path isn't set. Jared indicated the compiler has a ban on calling Path.GetTempPath within their codebase, so it's on the caller to specify a value.
---
 eng/config/BannedSymbols.txt                                   | 1 +
 .../Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker.cs        | 2 +-
 .../Serialization/AbstractOptionsSerializationService.cs       | 3 ++-
 .../Core/Portable/Serialization/SerializationExtensions.cs     | 3 ++-
 src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs   | 2 +-
 .../ProjectSystem/ProjectSystemProjectOptionsProcessor.cs      | 2 +-
 6 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/eng/config/BannedSymbols.txt b/eng/config/BannedSymbols.txt
index 42fd708fa29ec..631138488c6ed 100644
--- a/eng/config/BannedSymbols.txt
+++ b/eng/config/BannedSymbols.txt
@@ -70,4 +70,5 @@ M:Microsoft.CodeAnalysis.CodeActions.CodeAction.GetPreviewOperationsAsync(System
 M:Microsoft.CodeAnalysis.CodeActions.CodeAction.ComputeOperationsAsync(System.Threading.CancellationToken); Use overload that takes progress
 M:Microsoft.CodeAnalysis.CodeActions.CodeAction.GetChangedSolutionAsync(CSystem.Threading.CancellationToken); Use overload that takes progress
 M:Microsoft.CodeAnalysis.CodeActions.CodeAction.GetChangedDocumentAsync(CancellationToken); Use overload that takes progress
+M:Microsoft.CodeAnalysis.DesktopStrongNameProvider.#ctor(System.Collections.Immutable.ImmutableArray{System.String}); Use overload that takes in temp directory
 M:System.Diagnostics.Tracing.EventSource.WriteEvent(System.Int32,System.Object[]); Use WriteEventCore instead
\ No newline at end of file
diff --git a/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker.cs b/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker.cs
index cfd33c1999c2d..c20e6b522a7a4 100644
--- a/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker.cs
+++ b/src/Workspaces/Core/MSBuild/MSBuild/MSBuildProjectLoader.Worker.cs
@@ -352,7 +352,7 @@ private Task<ProjectInfo> CreateProjectInfoAsync(ProjectFileInfo projectFileInfo
                         .WithSourceReferenceResolver(new SourceFileResolver([], projectDirectory))
                         // TODO: https://github.com/dotnet/roslyn/issues/4967
                         .WithMetadataReferenceResolver(new WorkspaceMetadataFileReferenceResolver(metadataService, new RelativePathResolver([], projectDirectory)))
-                        .WithStrongNameProvider(new DesktopStrongNameProvider(commandLineArgs.KeyFileSearchPaths))
+                        .WithStrongNameProvider(new DesktopStrongNameProvider(commandLineArgs.KeyFileSearchPaths, Path.GetTempPath()))
                         .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
 
                     var documents = CreateDocumentInfos(projectFileInfo.Documents, projectId, commandLineArgs.Encoding);
diff --git a/src/Workspaces/Core/Portable/Serialization/AbstractOptionsSerializationService.cs b/src/Workspaces/Core/Portable/Serialization/AbstractOptionsSerializationService.cs
index 89535cf1d281f..3a296dba72ee3 100644
--- a/src/Workspaces/Core/Portable/Serialization/AbstractOptionsSerializationService.cs
+++ b/src/Workspaces/Core/Portable/Serialization/AbstractOptionsSerializationService.cs
@@ -6,6 +6,7 @@
 
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using Roslyn.Utilities;
@@ -158,7 +159,7 @@ protected static (
         var xmlReferenceResolver = XmlFileResolver.Default;
         var sourceReferenceResolver = SourceFileResolver.Default;
         var assemblyIdentityComparer = DesktopAssemblyIdentityComparer.Default;
-        var strongNameProvider = new DesktopStrongNameProvider();
+        var strongNameProvider = new DesktopStrongNameProvider(ImmutableArray<string>.Empty, Path.GetTempPath());
 
         return (
             outputKind,
diff --git a/src/Workspaces/Core/Portable/Serialization/SerializationExtensions.cs b/src/Workspaces/Core/Portable/Serialization/SerializationExtensions.cs
index 7d8890d20a2c6..76aa8fd1e4438 100644
--- a/src/Workspaces/Core/Portable/Serialization/SerializationExtensions.cs
+++ b/src/Workspaces/Core/Portable/Serialization/SerializationExtensions.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
+using System.IO;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
@@ -37,7 +38,7 @@ public static WellKnownSynchronizationKind GetWellKnownSynchronizationKind(this
     public static CompilationOptions FixUpCompilationOptions(this ProjectInfo.ProjectAttributes info, CompilationOptions compilationOptions)
     {
         return compilationOptions.WithXmlReferenceResolver(GetXmlResolver(info.FilePath))
-                                 .WithStrongNameProvider(new DesktopStrongNameProvider(GetStrongNameKeyPaths(info)));
+                                 .WithStrongNameProvider(new DesktopStrongNameProvider(GetStrongNameKeyPaths(info), Path.GetTempPath()));
     }
 
     private static XmlFileResolver GetXmlResolver(string? filePath)
diff --git a/src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs b/src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs
index 1929d87449ef5..b01bdd20308ee 100644
--- a/src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs
+++ b/src/Workspaces/Core/Portable/Workspace/CommandLineProject.cs
@@ -44,7 +44,7 @@ public static ProjectInfo CreateProjectInfo(string projectName, string language,
 
         var analyzerLoader = languageServices.SolutionServices.GetRequiredService<IAnalyzerService>().GetLoader();
         var xmlFileResolver = new XmlFileResolver(commandLineArguments.BaseDirectory);
-        var strongNameProvider = new DesktopStrongNameProvider(commandLineArguments.KeyFileSearchPaths);
+        var strongNameProvider = new DesktopStrongNameProvider(commandLineArguments.KeyFileSearchPaths, Path.GetTempPath());
 
         // Resolve all metadata references.
         //
diff --git a/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProjectOptionsProcessor.cs b/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProjectOptionsProcessor.cs
index 079e415d70645..11be0ef802128 100644
--- a/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProjectOptionsProcessor.cs
+++ b/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProjectOptionsProcessor.cs
@@ -192,7 +192,7 @@ private void UpdateProjectOptions_NoLock()
             .WithConcurrentBuild(concurrent: false)
             .WithXmlReferenceResolver(new XmlFileResolver(_commandLineArgumentsForCommandLine.BaseDirectory))
             .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default)
-            .WithStrongNameProvider(new DesktopStrongNameProvider(_commandLineArgumentsForCommandLine.KeyFileSearchPaths.WhereNotNull().ToImmutableArray()));
+            .WithStrongNameProvider(new DesktopStrongNameProvider(_commandLineArgumentsForCommandLine.KeyFileSearchPaths.WhereNotNull().ToImmutableArray(), Path.GetTempPath()));
 
         // Override the default documentation mode.
         var documentationMode = _commandLineArgumentsForCommandLine.DocumentationPath != null ? DocumentationMode.Diagnose : DocumentationMode.Parse;

From 9baba7e50c6cd172ed7427894cefb3ffc39d6b83 Mon Sep 17 00:00:00 2001
From: Todd Grunke <toddgrun@microsoft.com>
Date: Wed, 20 Mar 2024 17:02:29 -0700
Subject: [PATCH 160/170] Small allocation optimization in
 StateTable.Builder.ToImmutable (#72364)

Small performance optimization around in StateTable.Builder.ToImmutable to no longer allocate an array
---
 .../SourceGeneration/Nodes/StateTableStore.cs       | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/StateTableStore.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/StateTableStore.cs
index 24b653df7db29..609a22aba9ea7 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/StateTableStore.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/StateTableStore.cs
@@ -2,11 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
 using Microsoft.CodeAnalysis.Collections;
 
 namespace Microsoft.CodeAnalysis
@@ -51,10 +47,13 @@ public sealed class Builder
             public StateTableStore ToImmutable()
             {
                 // we can cache the tables at this point, as we'll no longer be using them to determine current state
-                var keys = _tableBuilder.Keys.ToArray();
-                foreach (var key in keys)
+                foreach (var kvp in _tableBuilder)
                 {
-                    _tableBuilder[key] = _tableBuilder[key].AsCached();
+                    var cachedValue = kvp.Value.AsCached();
+                    if (cachedValue != kvp.Value)
+                    {
+                        SegmentedCollectionsMarshal.GetValueRefOrNullRef(_tableBuilder, kvp.Key) = cachedValue;
+                    }
                 }
 
                 return new StateTableStore(_tableBuilder.ToImmutable());

From 74b3512f00d2d2c7c937a6fad05e786ee297ec4c Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Wed, 20 Mar 2024 17:14:33 -0700
Subject: [PATCH 161/170] Simpler on netcore

---
 ...pilationState.TranslationAction_Actions.cs | 26 +++++++++++++++----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index e4bdf7418da09..c717663a6de15 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -138,9 +138,12 @@ internal sealed class AddDocumentsAction(
 
             public override async Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
             {
+                using var _1 = ArrayBuilder<SyntaxTree>.GetInstance(this.Documents.Length, out var trees);
+
+#if NETSTANDARD
+
                 // Parallel parse the documents we have in chunks.
-                using var _ = ArrayBuilder<Task<SyntaxTree>>.GetInstance(AddDocumentsBatchSize, out var tasks);
-                var currentCompilation = oldCompilation;
+                using var _2 = ArrayBuilder<Task<SyntaxTree>>.GetInstance(AddDocumentsBatchSize, out var tasks);
 
                 // Can simplify this to use span-slicing once the language supports using ref-structs in async methods.
                 for (int batchStart = 0, total = this.Documents.Length; batchStart < total; batchStart += AddDocumentsBatchSize)
@@ -153,11 +156,24 @@ public override async Task<Compilation> TransformCompilationAsync(Compilation ol
                         tasks.Add(Task.Run(async () => await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false), cancellationToken));
                     }
 
-                    var trees = await Task.WhenAll(tasks).ConfigureAwait(false);
-                    currentCompilation = currentCompilation.AddSyntaxTrees(trees);
+                    var batch = await Task.WhenAll(tasks).ConfigureAwait(false);
+                    trees.AddRange(batch);
                 }
 
-                return currentCompilation;
+#else
+
+                await Parallel.ForEachAsync(
+                    this.Documents,
+                    cancellationToken,
+                    static async (document, cancellationToken) =>
+                        await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false)).ConfigureAwait(false);
+
+                foreach (var document in this.Documents)
+                    trees.Add(await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false));
+
+#endif
+
+                return oldCompilation.AddSyntaxTrees(trees);
             }
 
             // This action adds the specified trees, but leaves the generated trees untouched.

From 51c08bd7319fc51bcc510bf888a7901c157d01de Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Wed, 20 Mar 2024 21:47:06 -0700
Subject: [PATCH 162/170] Disable integration tests

---
 .../New.IntegrationTests/CSharp/CSharpSourceGenerators.cs   | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
index 62d7ed50cd236..27393c0f1362c 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
@@ -11,10 +11,10 @@
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.TestSourceGenerator;
-using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
 using Microsoft.VisualStudio.LanguageServices;
 using Microsoft.VisualStudio.Shell.TableControl;
+using Roslyn.Test.Utilities;
 using Roslyn.VisualStudio.IntegrationTests;
 using Roslyn.VisualStudio.IntegrationTests.InProcess;
 using Roslyn.VisualStudio.NewIntegrationTests.InProcess;
@@ -162,7 +162,7 @@ public static void Main()
             Assert.Equal(isPreview, await TestServices.Shell.IsActiveTabProvisionalAsync(HangMitigatingCancellationToken));
         }
 
-        [IdeFact]
+        [IdeFact, WorkItem("https://github.com/dotnet/roslyn/issues/72627")]
         public async Task InvokeNavigateToForGeneratedFile()
         {
             await TestServices.Shell.ShowNavigateToDialogAsync(HangMitigatingCancellationToken);
@@ -174,7 +174,7 @@ public async Task InvokeNavigateToForGeneratedFile()
             Assert.Equal(HelloWorldGenerator.GeneratedEnglishClassName, await TestServices.Editor.GetSelectedTextAsync(HangMitigatingCancellationToken));
         }
 
-        [IdeFact]
+        [IdeFact, WorkItem("https://github.com/dotnet/roslyn/issues/72627")]
         public async Task InvokeNavigateToForGeneratedFile_InFolder()
         {
             await TestServices.Shell.ShowNavigateToDialogAsync(HangMitigatingCancellationToken);

From 44136126d475c9ab0e6d65b4e71471eaea0a5308 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Wed, 20 Mar 2024 22:01:52 -0700
Subject: [PATCH 163/170] use semaphore

---
 ...pilationState.TranslationAction_Actions.cs | 32 +++++++++----------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index c717663a6de15..a900b1b5e52b1 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -138,28 +138,25 @@ internal sealed class AddDocumentsAction(
 
             public override async Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
             {
-                using var _1 = ArrayBuilder<SyntaxTree>.GetInstance(this.Documents.Length, out var trees);
-
 #if NETSTANDARD
 
-                // Parallel parse the documents we have in chunks.
-                using var _2 = ArrayBuilder<Task<SyntaxTree>>.GetInstance(AddDocumentsBatchSize, out var tasks);
+                using var _1 = ArrayBuilder<Task>.GetInstance(this.Documents.Length, out var tasks);
 
-                // Can simplify this to use span-slicing once the language supports using ref-structs in async methods.
-                for (int batchStart = 0, total = this.Documents.Length; batchStart < total; batchStart += AddDocumentsBatchSize)
+                // We want to parse in parallel.  But we don't want to have too many parses going on at the same time.
+                // So we use a semaphore here to only allow that many in at a time.  Once we hit that amount, it will
+                // block further parallel work.  However, as the semaphore is released, new work will be let in.
+                var semaphore = new SemaphoreSlim(initialCount: AddDocumentsBatchSize);
+                foreach (var document in this.Documents)
                 {
-                    tasks.Clear();
-
-                    for (int i = batchStart, batchEnd = Math.Min(batchStart + AddDocumentsBatchSize, total); i < batchEnd; i++)
+                    tasks.Add(Task.Run(async () =>
                     {
-                        var document = this.Documents[i];
-                        tasks.Add(Task.Run(async () => await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false), cancellationToken));
-                    }
-
-                    var batch = await Task.WhenAll(tasks).ConfigureAwait(false);
-                    trees.AddRange(batch);
+                        using (await semaphore.DisposableWaitAsync(cancellationToken).ConfigureAwait(false))
+                            await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+                    }, cancellationToken));
                 }
 
+                await Task.WhenAll(tasks).ConfigureAwait(false);
+
 #else
 
                 await Parallel.ForEachAsync(
@@ -168,11 +165,12 @@ await Parallel.ForEachAsync(
                     static async (document, cancellationToken) =>
                         await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false)).ConfigureAwait(false);
 
+#endif
+                using var _2 = ArrayBuilder<SyntaxTree>.GetInstance(this.Documents.Length, out var trees);
+
                 foreach (var document in this.Documents)
                     trees.Add(await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false));
 
-#endif
-
                 return oldCompilation.AddSyntaxTrees(trees);
             }
 

From cc749a02521fe70feeed524c8cb4d61f06b12ad6 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Wed, 20 Mar 2024 22:02:28 -0700
Subject: [PATCH 164/170] formaatting

---
 .../SolutionCompilationState.TranslationAction_Actions.cs    | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
index a900b1b5e52b1..9f15aed0ffec4 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs
@@ -139,7 +139,6 @@ internal sealed class AddDocumentsAction(
             public override async Task<Compilation> TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken)
             {
 #if NETSTANDARD
-
                 using var _1 = ArrayBuilder<Task>.GetInstance(this.Documents.Length, out var tasks);
 
                 // We want to parse in parallel.  But we don't want to have too many parses going on at the same time.
@@ -156,16 +155,14 @@ public override async Task<Compilation> TransformCompilationAsync(Compilation ol
                 }
 
                 await Task.WhenAll(tasks).ConfigureAwait(false);
-
 #else
-
                 await Parallel.ForEachAsync(
                     this.Documents,
                     cancellationToken,
                     static async (document, cancellationToken) =>
                         await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false)).ConfigureAwait(false);
-
 #endif
+
                 using var _2 = ArrayBuilder<SyntaxTree>.GetInstance(this.Documents.Length, out var trees);
 
                 foreach (var document in this.Documents)

From 484b3bb4eca558dbd3f1629a4a2effb257dff408 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Wed, 20 Mar 2024 23:05:50 -0700
Subject: [PATCH 165/170] skip

---
 .../New.IntegrationTests/CSharp/CSharpSourceGenerators.cs     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
index 27393c0f1362c..c3195928fad2d 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
@@ -162,7 +162,7 @@ public static void Main()
             Assert.Equal(isPreview, await TestServices.Shell.IsActiveTabProvisionalAsync(HangMitigatingCancellationToken));
         }
 
-        [IdeFact, WorkItem("https://github.com/dotnet/roslyn/issues/72627")]
+        [IdeFact(Skip = "https://github.com/dotnet/roslyn/issues/72627")]
         public async Task InvokeNavigateToForGeneratedFile()
         {
             await TestServices.Shell.ShowNavigateToDialogAsync(HangMitigatingCancellationToken);
@@ -174,7 +174,7 @@ public async Task InvokeNavigateToForGeneratedFile()
             Assert.Equal(HelloWorldGenerator.GeneratedEnglishClassName, await TestServices.Editor.GetSelectedTextAsync(HangMitigatingCancellationToken));
         }
 
-        [IdeFact, WorkItem("https://github.com/dotnet/roslyn/issues/72627")]
+        [IdeFact(Skip = "https://github.com/dotnet/roslyn/issues/72627")]
         public async Task InvokeNavigateToForGeneratedFile_InFolder()
         {
             await TestServices.Shell.ShowNavigateToDialogAsync(HangMitigatingCancellationToken);

From e2c2cda3ca26f5d41f07a769759c05f2fa23ced0 Mon Sep 17 00:00:00 2001
From: Cyrus Najmabadi <cyrus.najmaadi@gmail.com>
Date: Wed, 20 Mar 2024 23:08:06 -0700
Subject: [PATCH 166/170] remove

---
 .../New.IntegrationTests/CSharp/CSharpSourceGenerators.cs        | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs b/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
index c3195928fad2d..ccf02ff9335d4 100644
--- a/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
+++ b/src/VisualStudio/IntegrationTest/New.IntegrationTests/CSharp/CSharpSourceGenerators.cs
@@ -14,7 +14,6 @@
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
 using Microsoft.VisualStudio.LanguageServices;
 using Microsoft.VisualStudio.Shell.TableControl;
-using Roslyn.Test.Utilities;
 using Roslyn.VisualStudio.IntegrationTests;
 using Roslyn.VisualStudio.IntegrationTests.InProcess;
 using Roslyn.VisualStudio.NewIntegrationTests.InProcess;

From 9bd2481863a14306e3852375730c40904c6485b1 Mon Sep 17 00:00:00 2001
From: "dotnet-maestro[bot]"
 <42748379+dotnet-maestro[bot]@users.noreply.github.com>
Date: Thu, 21 Mar 2024 13:54:19 +0000
Subject: [PATCH 167/170] [main] Update dependencies from
 dotnet/source-build-externals (#72612)

[main] Update dependencies from dotnet/source-build-externals
---
 eng/Version.Details.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index ef377b201eba3..262a1246aa41e 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -2,9 +2,9 @@
 <Dependencies>
   <ProductDependencies>
     <!-- Intermediate is necessary for source build. -->
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-externals" Version="9.0.0-alpha.1.24161.3">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-externals" Version="9.0.0-alpha.1.24168.3">
       <Uri>https://github.com/dotnet/source-build-externals</Uri>
-      <Sha>472629e451a5a87410ea3670606f7235a4dd5a02</Sha>
+      <Sha>b46b7e6859f4094cd7f3e00dc0471d62f5d8d051</Sha>
       <SourceBuild RepoName="source-build-externals" ManagedOnly="true" />
     </Dependency>
     <!-- Intermediate is necessary for source build. -->

From b050e489fff5df1af84289f880f857b84966a5ca Mon Sep 17 00:00:00 2001
From: Jan Jones <janjones@microsoft.com>
Date: Thu, 21 Mar 2024 17:02:07 +0100
Subject: [PATCH 168/170] Suppress preexisting SDL errors (#72633)

---
 azure-pipelines-official.yml     |  2 ++
 eng/config/guardian/.gdnsuppress | 41 ++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 eng/config/guardian/.gdnsuppress

diff --git a/azure-pipelines-official.yml b/azure-pipelines-official.yml
index bd33388a7258b..3b713dea8d779 100644
--- a/azure-pipelines-official.yml
+++ b/azure-pipelines-official.yml
@@ -89,6 +89,8 @@ extends:
         os: windows
       sbom:
         enabled: false
+      suppression:
+        suppressionFile: $(Build.SourcesDirectory)\eng\config\guardian\.gdnsuppres
     pool:
       name: NetCore1ESPool-Svc-Internal
       image: windows.vs2022preview.amd64
diff --git a/eng/config/guardian/.gdnsuppress b/eng/config/guardian/.gdnsuppress
new file mode 100644
index 0000000000000..9ccb486a7ae08
--- /dev/null
+++ b/eng/config/guardian/.gdnsuppress
@@ -0,0 +1,41 @@
+{
+  "properties": {
+    "helpUri": "https://eng.ms/docs/microsoft-security/security/azure-security/cloudai-security-fundamentals-engineering/security-integration/guardian-wiki/microsoft-guardian/general/suppressions"
+  },
+  "version": "1.0.0",
+  "suppressionSets": {
+    "default": {
+      "name": "default",
+      "createdDate": "2024-03-21 01:38:07Z",
+      "lastUpdatedDate": "2024-03-21 01:38:07Z"
+    }
+  },
+  "results": {
+    "847ed085b811316467ddba6a5f31a5084c27c4bb1c4a7d584dc0e857018dc898": {
+      "signature": "847ed085b811316467ddba6a5f31a5084c27c4bb1c4a7d584dc0e857018dc898",
+      "alternativeSignatures": [
+        "3e868456152947a1ac244bf80f7f116223d51ec35a46334f64b621b35255a1aa"
+      ],
+      "target": "eng/build.ps1",
+      "line": 340,
+      "memberOf": [
+        "default"
+      ],
+      "tool": "psscriptanalyzer",
+      "ruleId": "PSAvoidUsingConvertToSecureStringWithPlainText",
+      "createdDate": "2024-03-21 01:38:07Z"
+    },
+    "ec3b30de7f7c5fca72d402bd7f34279d378700b16d98b2f3da9922fa8db3546f": {
+      "signature": "ec3b30de7f7c5fca72d402bd7f34279d378700b16d98b2f3da9922fa8db3546f",
+      "alternativeSignatures": [],
+      "target": "src/EditorFeatures/CSharpTest2/EmbeddedLanguages/Json/CSharpJsonParserTests_BasicTests.cs",
+      "line": 4207,
+      "memberOf": [
+        "default"
+      ],
+      "tool": "credscan",
+      "ruleId": "CSCAN-GENERAL0060",
+      "createdDate": "2024-03-21 01:38:07Z"
+    }
+  }
+}
\ No newline at end of file

From 2f72b4d947a31d0fa871f887a31eae51dc49f820 Mon Sep 17 00:00:00 2001
From: Julien Couvreur <jcouv@users.noreply.github.com>
Date: Thu, 21 Mar 2024 11:30:59 -0700
Subject: [PATCH 169/170] Prefer pattern-based over interface-based disposal in
 await using (#72598)

---
 .../Compiler Breaking Changes - DotNet 8.md   |  23 +
 .../Portable/Binder/UsingStatementBinder.cs   |  39 +-
 .../Emit/CodeGen/CodeGenAwaitUsingTests.cs    | 895 +++++++++++++++---
 .../CodeGen/CodeGenUsingDeclarationTests.cs   |  31 +-
 .../IOperationTests_IUsingStatement.cs        | 344 ++++++-
 .../Semantics/UsingDeclarationTests.cs        |   5 +-
 6 files changed, 1177 insertions(+), 160 deletions(-)

diff --git a/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 8.md b/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 8.md
index 6bca00047ff0e..21a6b0e2e4cb1 100644
--- a/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 8.md	
+++ b/docs/compilers/CSharp/Compiler Breaking Changes - DotNet 8.md	
@@ -101,3 +101,26 @@ static class C
     public static string M(I2 o, in int x) => "2";
 }
 ```
+
+## Prefer pattern-based over interface-based disposal in async `using`
+
+***Introduced in Visual Studio 2022 version 17.10p3***
+
+An async `using` prefers to bind using a pattern-based `DisposeAsync()` method rather than the interface-based `IAsyncDisposable.DisposeAsync()`.
+
+For instance, the public `DisposeAsync()` method will be picked, rather than the private interface implementation:
+```csharp
+await using (var x = new C()) { }
+
+public class C : System.IAsyncDisposable
+{
+    ValueTask IAsyncDisposable.DisposeAsync() => throw null; // no longer picked
+
+    public async ValueTask DisposeAsync()
+    {
+        Console.WriteLine("PICKED");
+        await Task.Yield();
+    }
+}
+```
+
diff --git a/src/Compilers/CSharp/Portable/Binder/UsingStatementBinder.cs b/src/Compilers/CSharp/Portable/Binder/UsingStatementBinder.cs
index c18557aa94bd6..522d191faa3db 100644
--- a/src/Compilers/CSharp/Portable/Binder/UsingStatementBinder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/UsingStatementBinder.cs
@@ -183,31 +183,13 @@ internal static BoundStatement BindUsingStatementOrDeclarationFromParts(SyntaxNo
 
             bool bindDisposable(bool fromExpression, out MethodArgumentInfo? patternDisposeInfo, out TypeSymbol? awaitableType)
             {
-                TypeSymbol disposableInterface = getDisposableInterface(hasAwait);
-                Debug.Assert((object)disposableInterface != null);
-
-                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = originalBinder.GetNewCompoundUseSiteInfo(diagnostics);
-                Conversion iDisposableConversion = classifyConversion(fromExpression, disposableInterface, ref useSiteInfo);
                 patternDisposeInfo = null;
                 awaitableType = null;
-
-                diagnostics.Add(syntax, useSiteInfo);
-
-                if (iDisposableConversion.IsImplicit)
-                {
-                    if (hasAwait)
-                    {
-                        awaitableType = originalBinder.Compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_ValueTask);
-                    }
-
-                    return !ReportUseSite(disposableInterface, diagnostics, hasAwait ? awaitKeyword : usingKeyword);
-                }
-
                 Debug.Assert(!fromExpression || expressionOpt != null);
                 TypeSymbol? type = fromExpression ? expressionOpt!.Type : declarationTypeOpt;
 
+                // Pattern-based binding
                 // If this is a ref struct, or we're in a valid asynchronous using, try binding via pattern.
-                // We won't need to try and bind a second time if it fails, as async dispose can't be pattern based (ref structs are not allowed in async methods)
                 if (type is object && (type.IsRefLikeType || hasAwait))
                 {
                     BoundExpression? receiver = fromExpression
@@ -250,6 +232,25 @@ bool bindDisposable(bool fromExpression, out MethodArgumentInfo? patternDisposeI
                     }
                 }
 
+                // Interface binding
+                TypeSymbol disposableInterface = getDisposableInterface(hasAwait);
+                Debug.Assert((object)disposableInterface != null);
+
+                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = originalBinder.GetNewCompoundUseSiteInfo(diagnostics);
+                Conversion iDisposableConversion = classifyConversion(fromExpression, disposableInterface, ref useSiteInfo);
+
+                diagnostics.Add(syntax, useSiteInfo);
+
+                if (iDisposableConversion.IsImplicit)
+                {
+                    if (hasAwait)
+                    {
+                        awaitableType = originalBinder.Compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_ValueTask);
+                    }
+
+                    return !ReportUseSite(disposableInterface, diagnostics, hasAwait ? awaitKeyword : usingKeyword);
+                }
+
                 if (type is null || !type.IsErrorType())
                 {
                     // Retry with a different assumption about whether the `using` is async
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAwaitUsingTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAwaitUsingTests.cs
index 546d49a7fea95..c388178fb6771 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAwaitUsingTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAwaitUsingTests.cs
@@ -16,7 +16,7 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
     public class CodeGenAwaitUsingTests : CSharpTestBase
     {
         [Fact]
-        public void TestWithCSharp7_3()
+        public void TestWithCSharp7_3_01()
         {
             string source = @"
 class C : System.IAsyncDisposable
@@ -27,7 +27,7 @@ async System.Threading.Tasks.Task M()
         {
         }
     }
-    public System.Threading.Tasks.ValueTask DisposeAsync()
+    System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()
     {
         throw null;
     }
@@ -41,6 +41,35 @@ public System.Threading.Tasks.ValueTask DisposeAsync()
                 );
         }
 
+        [Fact]
+        public void TestWithCSharp7_3_02()
+        {
+            string source = @"
+class C : System.IAsyncDisposable
+{
+    async System.Threading.Tasks.Task M()
+    {
+        await using (var x = new C())
+        {
+        }
+    }
+    public System.Threading.Tasks.ValueTask DisposeAsync()
+    {
+        throw null;
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, parseOptions: TestOptions.Regular7_3);
+            comp.VerifyDiagnostics(
+                // (6,9): error CS8652: The feature 'asynchronous using' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //         await using (var x = new C())
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "await").WithArguments("asynchronous using", "8.0").WithLocation(6, 9),
+                // 0.cs(6,22): error CS8370: Feature 'pattern-based disposal' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //         await using (var x = new C())
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "var x = new C()").WithArguments("pattern-based disposal", "8.0").WithLocation(6, 22)
+                );
+        }
+
         [Fact]
         public void TestInNonAsyncVoidMethod()
         {
@@ -247,7 +276,7 @@ public System.Threading.Tasks.ValueTask DisposeAsync()
         }
 
         [Fact]
-        public void TestWithObsoleteDisposeAsync()
+        public void TestWithObsoleteDisposeAsync_01()
         {
             string source = @"
 class C : System.IAsyncDisposable
@@ -259,7 +288,7 @@ public static async System.Threading.Tasks.Task Main()
         }
     }
     [System.Obsolete]
-    public async System.Threading.Tasks.ValueTask DisposeAsync()
+    async System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()
     {
         await System.Threading.Tasks.Task.Yield();
     }
@@ -270,6 +299,33 @@ public async System.Threading.Tasks.ValueTask DisposeAsync()
             // https://github.com/dotnet/roslyn/issues/30257 Confirm whether this behavior is ok (currently matching behavior of obsolete Dispose in non-async using)
         }
 
+        [Fact]
+        public void TestWithObsoleteDisposeAsync_02()
+        {
+            string source = @"
+class C : System.IAsyncDisposable
+{
+    public static async System.Threading.Tasks.Task Main()
+    {
+        await using (var x = new C())
+        {
+        }
+    }
+    [System.Obsolete]
+    public async System.Threading.Tasks.ValueTask DisposeAsync()
+    {
+        await System.Threading.Tasks.Task.Yield();
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe);
+            comp.VerifyDiagnostics(
+                // 0.cs(6,22): warning CS0612: 'C.DisposeAsync()' is obsolete
+                //         await using (var x = new C())
+                Diagnostic(ErrorCode.WRN_DeprecatedSymbol, "var x = new C()").WithArguments("C.DisposeAsync()").WithLocation(6, 22)
+                );
+        }
+
         [Fact]
         public void TestWithObsoleteDispose()
         {
@@ -665,7 +721,7 @@ public void Dispose()
         }
 
         [Fact]
-        public void TestBadDisposeAsync()
+        public void TestBadDisposeAsync_01()
         {
             string source = @"
 namespace System
@@ -682,7 +738,7 @@ async System.Threading.Tasks.Task<int> M<T>()
         await using (new C()) { }
         await using (var x = new C()) { return 1; }
     }
-    public int DisposeAsync()
+    int System.IAsyncDisposable.DisposeAsync()
     {
         throw null;
     }
@@ -701,12 +757,47 @@ public int DisposeAsync()
         }
 
         [Fact]
-        public void TestMissingTaskType()
+        public void TestBadDisposeAsync_02()
+        {
+            string source = @"
+namespace System
+{
+    public interface IAsyncDisposable
+    {
+        int DisposeAsync(); // bad return type
+    }
+}
+class C : System.IAsyncDisposable
+{
+    async System.Threading.Tasks.Task<int> M<T>()
+    {
+        await using (new C()) { }
+        await using (var x = new C()) { return 1; }
+    }
+    public int DisposeAsync()
+    {
+        throw null;
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(source);
+            comp.VerifyDiagnostics(
+                // (13,22): error CS1061: 'int' does not contain a definition for 'GetAwaiter' and no accessible extension method 'GetAwaiter' accepting a first argument of type 'int' could be found (are you missing a using directive or an assembly reference?)
+                //         await using (new C()) { }
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "new C()").WithArguments("int", "GetAwaiter").WithLocation(13, 22),
+                // (14,22): error CS1061: 'int' does not contain a definition for 'GetAwaiter' and no accessible extension method 'GetAwaiter' accepting a first argument of type 'int' could be found (are you missing a using directive or an assembly reference?)
+                //         await using (var x = new C()) { return 1; }
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "var x = new C()").WithArguments("int", "GetAwaiter").WithLocation(14, 22)
+                );
+        }
+
+        [Fact]
+        public void TestMissingTaskType_01()
         {
             string lib_cs = @"
 public class Base : System.IAsyncDisposable
 {
-    public System.Threading.Tasks.ValueTask DisposeAsync()
+    System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()
     {
         System.Console.Write(""DisposeAsync"");
         return new System.Threading.Tasks.ValueTask(System.Threading.Tasks.Task.CompletedTask);
@@ -737,6 +828,39 @@ public static async System.Threading.Tasks.Task<int> Main()
                 );
         }
 
+        [Fact]
+        public void TestMissingTaskType_02()
+        {
+            string lib_cs = @"
+public class Base : System.IAsyncDisposable
+{
+    public System.Threading.Tasks.ValueTask DisposeAsync()
+    {
+        System.Console.Write(""DisposeAsync"");
+        return new System.Threading.Tasks.ValueTask(System.Threading.Tasks.Task.CompletedTask);
+    }
+}
+";
+
+            string comp_cs = @"
+public class C : Base
+{
+    public static async System.Threading.Tasks.Task<int> Main()
+    {
+        await using (var x = new C())
+        {
+            System.Console.Write(""body "");
+            return 1;
+        }
+    }
+}
+";
+            var libComp = CreateCompilationWithTasksExtensions(lib_cs + IAsyncDisposableDefinition);
+            var comp = CreateCompilationWithTasksExtensions(comp_cs, references: new[] { libComp.EmitToImageReference() }, options: TestOptions.DebugExe);
+            comp.MakeTypeMissing(WellKnownType.System_Threading_Tasks_ValueTask);
+            comp.VerifyEmitDiagnostics();
+        }
+
         [Fact]
         public void TestWithDeclaration()
         {
@@ -952,7 +1076,7 @@ public System.Threading.Tasks.ValueTask DisposeAsync()
         }
 
         [Fact]
-        public void TestWithExpression()
+        public void TestWithExpression_01()
         {
             string source = @"
 class C : System.IAsyncDisposable
@@ -965,7 +1089,7 @@ public static async System.Threading.Tasks.Task Main()
             return;
         }
     }
-    public System.Threading.Tasks.ValueTask DisposeAsync()
+    System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()
     {
         System.Console.Write(""DisposeAsync"");
         return new System.Threading.Tasks.ValueTask(System.Threading.Tasks.Task.CompletedTask);
@@ -1126,84 +1250,14 @@ .locals init (int V_0,
         }
 
         [Fact]
-        public void TestWithNullExpression()
-        {
-            string source = @"
-class C
-{
-    public static async System.Threading.Tasks.Task Main()
-    {
-        await using (null)
-        {
-            System.Console.Write(""body"");
-            return;
-        }
-    }
-}
-";
-            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe);
-            comp.VerifyDiagnostics();
-            CompileAndVerify(comp, expectedOutput: "body");
-        }
-
-        [Fact]
-        public void TestWithMethodName()
-        {
-            string source = @"
-class C
-{
-    public static async System.Threading.Tasks.Task Main()
-    {
-        await using (Main)
-        {
-        }
-    }
-}
-";
-            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition });
-            comp.VerifyDiagnostics(
-                // (6,22): error CS8410: 'method group': type used in an async using statement must be implicitly convertible to 'System.IAsyncDisposable'
-                //         await using (Main)
-                Diagnostic(ErrorCode.ERR_NoConvToIAsyncDisp, "Main").WithArguments("method group").WithLocation(6, 22)
-                );
-        }
-
-        [Fact]
-        public void TestWithDynamicExpression()
+        public void TestWithExpression_02()
         {
             string source = @"
 class C : System.IAsyncDisposable
 {
     public static async System.Threading.Tasks.Task Main()
     {
-        dynamic d = new C();
-        await using (d)
-        {
-            System.Console.Write(""body "");
-            return;
-        }
-    }
-    public System.Threading.Tasks.ValueTask DisposeAsync()
-    {
-        System.Console.Write(""DisposeAsync"");
-        return new System.Threading.Tasks.ValueTask(System.Threading.Tasks.Task.CompletedTask);
-    }
-}
-";
-            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe, references: new[] { CSharpRef });
-            comp.VerifyDiagnostics();
-            CompileAndVerify(comp, expectedOutput: "body DisposeAsync");
-        }
-
-        [Fact]
-        public void TestWithStructExpression()
-        {
-            string source = @"
-struct S : System.IAsyncDisposable
-{
-    public static async System.Threading.Tasks.Task Main()
-    {
-        await using (new S())
+        await using (new C())
         {
             System.Console.Write(""body "");
             return;
@@ -1219,67 +1273,487 @@ public System.Threading.Tasks.ValueTask DisposeAsync()
             var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe);
             comp.VerifyDiagnostics();
             var verifier = CompileAndVerify(comp, expectedOutput: "body DisposeAsync");
-            verifier.VerifyIL("S.<Main>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+            verifier.VerifyIL("C.<Main>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
 {
-  // Code size      298 (0x12a)
+  // Code size      306 (0x132)
   .maxstack  3
   .locals init (int V_0,
                 object V_1,
                 System.Runtime.CompilerServices.ValueTaskAwaiter V_2,
                 System.Threading.Tasks.ValueTask V_3,
-                S.<Main>d__0 V_4,
+                C.<Main>d__0 V_4,
                 System.Exception V_5,
                 int V_6)
   IL_0000:  ldarg.0
-  IL_0001:  ldfld      ""int S.<Main>d__0.<>1__state""
+  IL_0001:  ldfld      ""int C.<Main>d__0.<>1__state""
   IL_0006:  stloc.0
   .try
   {
     IL_0007:  ldloc.0
     IL_0008:  brfalse.s  IL_000c
     IL_000a:  br.s       IL_0011
-    IL_000c:  br         IL_0098
+    IL_000c:  br         IL_0099
     IL_0011:  nop
     IL_0012:  ldarg.0
-    IL_0013:  ldflda     ""S S.<Main>d__0.<>s__1""
-    IL_0018:  initobj    ""S""
-    IL_001e:  ldarg.0
-    IL_001f:  ldnull
-    IL_0020:  stfld      ""object S.<Main>d__0.<>s__2""
-    IL_0025:  ldarg.0
-    IL_0026:  ldc.i4.0
-    IL_0027:  stfld      ""int S.<Main>d__0.<>s__3""
+    IL_0013:  newobj     ""C..ctor()""
+    IL_0018:  stfld      ""C C.<Main>d__0.<>s__1""
+    IL_001d:  ldarg.0
+    IL_001e:  ldnull
+    IL_001f:  stfld      ""object C.<Main>d__0.<>s__2""
+    IL_0024:  ldarg.0
+    IL_0025:  ldc.i4.0
+    IL_0026:  stfld      ""int C.<Main>d__0.<>s__3""
     .try
     {
-      IL_002c:  nop
-      IL_002d:  ldstr      ""body ""
-      IL_0032:  call       ""void System.Console.Write(string)""
-      IL_0037:  nop
-      IL_0038:  br.s       IL_003a
-      IL_003a:  ldarg.0
-      IL_003b:  ldc.i4.1
-      IL_003c:  stfld      ""int S.<Main>d__0.<>s__3""
-      IL_0041:  leave.s    IL_004d
+      IL_002b:  nop
+      IL_002c:  ldstr      ""body ""
+      IL_0031:  call       ""void System.Console.Write(string)""
+      IL_0036:  nop
+      IL_0037:  br.s       IL_0039
+      IL_0039:  ldarg.0
+      IL_003a:  ldc.i4.1
+      IL_003b:  stfld      ""int C.<Main>d__0.<>s__3""
+      IL_0040:  leave.s    IL_004c
     }
     catch object
     {
-      IL_0043:  stloc.1
-      IL_0044:  ldarg.0
-      IL_0045:  ldloc.1
-      IL_0046:  stfld      ""object S.<Main>d__0.<>s__2""
-      IL_004b:  leave.s    IL_004d
+      IL_0042:  stloc.1
+      IL_0043:  ldarg.0
+      IL_0044:  ldloc.1
+      IL_0045:  stfld      ""object C.<Main>d__0.<>s__2""
+      IL_004a:  leave.s    IL_004c
     }
-    IL_004d:  ldarg.0
-    IL_004e:  ldflda     ""S S.<Main>d__0.<>s__1""
-    IL_0053:  constrained. ""S""
-    IL_0059:  callvirt   ""System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()""
-    IL_005e:  stloc.3
-    IL_005f:  ldloca.s   V_3
-    IL_0061:  call       ""System.Runtime.CompilerServices.ValueTaskAwaiter System.Threading.Tasks.ValueTask.GetAwaiter()""
-    IL_0066:  stloc.2
-    IL_0067:  ldloca.s   V_2
-    IL_0069:  call       ""bool System.Runtime.CompilerServices.ValueTaskAwaiter.IsCompleted.get""
-    IL_006e:  brtrue.s   IL_00b4
+    IL_004c:  ldarg.0
+    IL_004d:  ldfld      ""C C.<Main>d__0.<>s__1""
+    IL_0052:  brfalse.s  IL_00bd
+    IL_0054:  ldarg.0
+    IL_0055:  ldfld      ""C C.<Main>d__0.<>s__1""
+    IL_005a:  callvirt   ""System.Threading.Tasks.ValueTask C.DisposeAsync()""
+    IL_005f:  stloc.3
+    IL_0060:  ldloca.s   V_3
+    IL_0062:  call       ""System.Runtime.CompilerServices.ValueTaskAwaiter System.Threading.Tasks.ValueTask.GetAwaiter()""
+    IL_0067:  stloc.2
+    IL_0068:  ldloca.s   V_2
+    IL_006a:  call       ""bool System.Runtime.CompilerServices.ValueTaskAwaiter.IsCompleted.get""
+    IL_006f:  brtrue.s   IL_00b5
+    IL_0071:  ldarg.0
+    IL_0072:  ldc.i4.0
+    IL_0073:  dup
+    IL_0074:  stloc.0
+    IL_0075:  stfld      ""int C.<Main>d__0.<>1__state""
+    IL_007a:  ldarg.0
+    IL_007b:  ldloc.2
+    IL_007c:  stfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C.<Main>d__0.<>u__1""
+    IL_0081:  ldarg.0
+    IL_0082:  stloc.s    V_4
+    IL_0084:  ldarg.0
+    IL_0085:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<Main>d__0.<>t__builder""
+    IL_008a:  ldloca.s   V_2
+    IL_008c:  ldloca.s   V_4
+    IL_008e:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.ValueTaskAwaiter, C.<Main>d__0>(ref System.Runtime.CompilerServices.ValueTaskAwaiter, ref C.<Main>d__0)""
+    IL_0093:  nop
+    IL_0094:  leave      IL_0131
+    IL_0099:  ldarg.0
+    IL_009a:  ldfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C.<Main>d__0.<>u__1""
+    IL_009f:  stloc.2
+    IL_00a0:  ldarg.0
+    IL_00a1:  ldflda     ""System.Runtime.CompilerServices.ValueTaskAwaiter C.<Main>d__0.<>u__1""
+    IL_00a6:  initobj    ""System.Runtime.CompilerServices.ValueTaskAwaiter""
+    IL_00ac:  ldarg.0
+    IL_00ad:  ldc.i4.m1
+    IL_00ae:  dup
+    IL_00af:  stloc.0
+    IL_00b0:  stfld      ""int C.<Main>d__0.<>1__state""
+    IL_00b5:  ldloca.s   V_2
+    IL_00b7:  call       ""void System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult()""
+    IL_00bc:  nop
+    IL_00bd:  ldarg.0
+    IL_00be:  ldfld      ""object C.<Main>d__0.<>s__2""
+    IL_00c3:  stloc.1
+    IL_00c4:  ldloc.1
+    IL_00c5:  brfalse.s  IL_00e2
+    IL_00c7:  ldloc.1
+    IL_00c8:  isinst     ""System.Exception""
+    IL_00cd:  stloc.s    V_5
+    IL_00cf:  ldloc.s    V_5
+    IL_00d1:  brtrue.s   IL_00d5
+    IL_00d3:  ldloc.1
+    IL_00d4:  throw
+    IL_00d5:  ldloc.s    V_5
+    IL_00d7:  call       ""System.Runtime.ExceptionServices.ExceptionDispatchInfo System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(System.Exception)""
+    IL_00dc:  callvirt   ""void System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()""
+    IL_00e1:  nop
+    IL_00e2:  ldarg.0
+    IL_00e3:  ldfld      ""int C.<Main>d__0.<>s__3""
+    IL_00e8:  stloc.s    V_6
+    IL_00ea:  ldloc.s    V_6
+    IL_00ec:  ldc.i4.1
+    IL_00ed:  beq.s      IL_00f1
+    IL_00ef:  br.s       IL_00f3
+    IL_00f1:  leave.s    IL_011d
+    IL_00f3:  ldarg.0
+    IL_00f4:  ldnull
+    IL_00f5:  stfld      ""object C.<Main>d__0.<>s__2""
+    IL_00fa:  ldarg.0
+    IL_00fb:  ldnull
+    IL_00fc:  stfld      ""C C.<Main>d__0.<>s__1""
+    IL_0101:  leave.s    IL_011d
+  }
+  catch System.Exception
+  {
+    IL_0103:  stloc.s    V_5
+    IL_0105:  ldarg.0
+    IL_0106:  ldc.i4.s   -2
+    IL_0108:  stfld      ""int C.<Main>d__0.<>1__state""
+    IL_010d:  ldarg.0
+    IL_010e:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<Main>d__0.<>t__builder""
+    IL_0113:  ldloc.s    V_5
+    IL_0115:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetException(System.Exception)""
+    IL_011a:  nop
+    IL_011b:  leave.s    IL_0131
+  }
+  IL_011d:  ldarg.0
+  IL_011e:  ldc.i4.s   -2
+  IL_0120:  stfld      ""int C.<Main>d__0.<>1__state""
+  IL_0125:  ldarg.0
+  IL_0126:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<Main>d__0.<>t__builder""
+  IL_012b:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetResult()""
+  IL_0130:  nop
+  IL_0131:  ret
+}
+");
+        }
+
+        [Fact]
+        public void TestWithExpression_03()
+        {
+            string source = @"
+class C
+{
+    public static async System.Threading.Tasks.Task Main()
+    {
+        await using (new C())
+        {
+            System.Console.Write(""body "");
+            return;
+        }
+    }
+    public System.Threading.Tasks.ValueTask DisposeAsync()
+    {
+        System.Console.Write(""DisposeAsync"");
+        return new System.Threading.Tasks.ValueTask(System.Threading.Tasks.Task.CompletedTask);
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe);
+            comp.VerifyDiagnostics();
+            var verifier = CompileAndVerify(comp, expectedOutput: "body DisposeAsync");
+            verifier.VerifyIL("C.<Main>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+{
+  // Code size      306 (0x132)
+  .maxstack  3
+  .locals init (int V_0,
+                object V_1,
+                System.Runtime.CompilerServices.ValueTaskAwaiter V_2,
+                System.Threading.Tasks.ValueTask V_3,
+                C.<Main>d__0 V_4,
+                System.Exception V_5,
+                int V_6)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int C.<Main>d__0.<>1__state""
+  IL_0006:  stloc.0
+  .try
+  {
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_000c
+    IL_000a:  br.s       IL_0011
+    IL_000c:  br         IL_0099
+    IL_0011:  nop
+    IL_0012:  ldarg.0
+    IL_0013:  newobj     ""C..ctor()""
+    IL_0018:  stfld      ""C C.<Main>d__0.<>s__1""
+    IL_001d:  ldarg.0
+    IL_001e:  ldnull
+    IL_001f:  stfld      ""object C.<Main>d__0.<>s__2""
+    IL_0024:  ldarg.0
+    IL_0025:  ldc.i4.0
+    IL_0026:  stfld      ""int C.<Main>d__0.<>s__3""
+    .try
+    {
+      IL_002b:  nop
+      IL_002c:  ldstr      ""body ""
+      IL_0031:  call       ""void System.Console.Write(string)""
+      IL_0036:  nop
+      IL_0037:  br.s       IL_0039
+      IL_0039:  ldarg.0
+      IL_003a:  ldc.i4.1
+      IL_003b:  stfld      ""int C.<Main>d__0.<>s__3""
+      IL_0040:  leave.s    IL_004c
+    }
+    catch object
+    {
+      IL_0042:  stloc.1
+      IL_0043:  ldarg.0
+      IL_0044:  ldloc.1
+      IL_0045:  stfld      ""object C.<Main>d__0.<>s__2""
+      IL_004a:  leave.s    IL_004c
+    }
+    IL_004c:  ldarg.0
+    IL_004d:  ldfld      ""C C.<Main>d__0.<>s__1""
+    IL_0052:  brfalse.s  IL_00bd
+    IL_0054:  ldarg.0
+    IL_0055:  ldfld      ""C C.<Main>d__0.<>s__1""
+    IL_005a:  callvirt   ""System.Threading.Tasks.ValueTask C.DisposeAsync()""
+    IL_005f:  stloc.3
+    IL_0060:  ldloca.s   V_3
+    IL_0062:  call       ""System.Runtime.CompilerServices.ValueTaskAwaiter System.Threading.Tasks.ValueTask.GetAwaiter()""
+    IL_0067:  stloc.2
+    IL_0068:  ldloca.s   V_2
+    IL_006a:  call       ""bool System.Runtime.CompilerServices.ValueTaskAwaiter.IsCompleted.get""
+    IL_006f:  brtrue.s   IL_00b5
+    IL_0071:  ldarg.0
+    IL_0072:  ldc.i4.0
+    IL_0073:  dup
+    IL_0074:  stloc.0
+    IL_0075:  stfld      ""int C.<Main>d__0.<>1__state""
+    IL_007a:  ldarg.0
+    IL_007b:  ldloc.2
+    IL_007c:  stfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C.<Main>d__0.<>u__1""
+    IL_0081:  ldarg.0
+    IL_0082:  stloc.s    V_4
+    IL_0084:  ldarg.0
+    IL_0085:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<Main>d__0.<>t__builder""
+    IL_008a:  ldloca.s   V_2
+    IL_008c:  ldloca.s   V_4
+    IL_008e:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.ValueTaskAwaiter, C.<Main>d__0>(ref System.Runtime.CompilerServices.ValueTaskAwaiter, ref C.<Main>d__0)""
+    IL_0093:  nop
+    IL_0094:  leave      IL_0131
+    IL_0099:  ldarg.0
+    IL_009a:  ldfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter C.<Main>d__0.<>u__1""
+    IL_009f:  stloc.2
+    IL_00a0:  ldarg.0
+    IL_00a1:  ldflda     ""System.Runtime.CompilerServices.ValueTaskAwaiter C.<Main>d__0.<>u__1""
+    IL_00a6:  initobj    ""System.Runtime.CompilerServices.ValueTaskAwaiter""
+    IL_00ac:  ldarg.0
+    IL_00ad:  ldc.i4.m1
+    IL_00ae:  dup
+    IL_00af:  stloc.0
+    IL_00b0:  stfld      ""int C.<Main>d__0.<>1__state""
+    IL_00b5:  ldloca.s   V_2
+    IL_00b7:  call       ""void System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult()""
+    IL_00bc:  nop
+    IL_00bd:  ldarg.0
+    IL_00be:  ldfld      ""object C.<Main>d__0.<>s__2""
+    IL_00c3:  stloc.1
+    IL_00c4:  ldloc.1
+    IL_00c5:  brfalse.s  IL_00e2
+    IL_00c7:  ldloc.1
+    IL_00c8:  isinst     ""System.Exception""
+    IL_00cd:  stloc.s    V_5
+    IL_00cf:  ldloc.s    V_5
+    IL_00d1:  brtrue.s   IL_00d5
+    IL_00d3:  ldloc.1
+    IL_00d4:  throw
+    IL_00d5:  ldloc.s    V_5
+    IL_00d7:  call       ""System.Runtime.ExceptionServices.ExceptionDispatchInfo System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(System.Exception)""
+    IL_00dc:  callvirt   ""void System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()""
+    IL_00e1:  nop
+    IL_00e2:  ldarg.0
+    IL_00e3:  ldfld      ""int C.<Main>d__0.<>s__3""
+    IL_00e8:  stloc.s    V_6
+    IL_00ea:  ldloc.s    V_6
+    IL_00ec:  ldc.i4.1
+    IL_00ed:  beq.s      IL_00f1
+    IL_00ef:  br.s       IL_00f3
+    IL_00f1:  leave.s    IL_011d
+    IL_00f3:  ldarg.0
+    IL_00f4:  ldnull
+    IL_00f5:  stfld      ""object C.<Main>d__0.<>s__2""
+    IL_00fa:  ldarg.0
+    IL_00fb:  ldnull
+    IL_00fc:  stfld      ""C C.<Main>d__0.<>s__1""
+    IL_0101:  leave.s    IL_011d
+  }
+  catch System.Exception
+  {
+    IL_0103:  stloc.s    V_5
+    IL_0105:  ldarg.0
+    IL_0106:  ldc.i4.s   -2
+    IL_0108:  stfld      ""int C.<Main>d__0.<>1__state""
+    IL_010d:  ldarg.0
+    IL_010e:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<Main>d__0.<>t__builder""
+    IL_0113:  ldloc.s    V_5
+    IL_0115:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetException(System.Exception)""
+    IL_011a:  nop
+    IL_011b:  leave.s    IL_0131
+  }
+  IL_011d:  ldarg.0
+  IL_011e:  ldc.i4.s   -2
+  IL_0120:  stfld      ""int C.<Main>d__0.<>1__state""
+  IL_0125:  ldarg.0
+  IL_0126:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<Main>d__0.<>t__builder""
+  IL_012b:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetResult()""
+  IL_0130:  nop
+  IL_0131:  ret
+}
+");
+        }
+
+        [Fact]
+        public void TestWithNullExpression()
+        {
+            string source = @"
+class C
+{
+    public static async System.Threading.Tasks.Task Main()
+    {
+        await using (null)
+        {
+            System.Console.Write(""body"");
+            return;
+        }
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe);
+            comp.VerifyDiagnostics();
+            CompileAndVerify(comp, expectedOutput: "body");
+        }
+
+        [Fact]
+        public void TestWithMethodName()
+        {
+            string source = @"
+class C
+{
+    public static async System.Threading.Tasks.Task Main()
+    {
+        await using (Main)
+        {
+        }
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition });
+            comp.VerifyDiagnostics(
+                // (6,22): error CS8410: 'method group': type used in an async using statement must be implicitly convertible to 'System.IAsyncDisposable'
+                //         await using (Main)
+                Diagnostic(ErrorCode.ERR_NoConvToIAsyncDisp, "Main").WithArguments("method group").WithLocation(6, 22)
+                );
+        }
+
+        [Fact]
+        public void TestWithDynamicExpression()
+        {
+            string source = @"
+class C : System.IAsyncDisposable
+{
+    public static async System.Threading.Tasks.Task Main()
+    {
+        dynamic d = new C();
+        await using (d)
+        {
+            System.Console.Write(""body "");
+            return;
+        }
+    }
+    public System.Threading.Tasks.ValueTask DisposeAsync()
+    {
+        System.Console.Write(""DisposeAsync"");
+        return new System.Threading.Tasks.ValueTask(System.Threading.Tasks.Task.CompletedTask);
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe, references: new[] { CSharpRef });
+            comp.VerifyDiagnostics();
+            CompileAndVerify(comp, expectedOutput: "body DisposeAsync");
+        }
+
+        [Fact]
+        public void TestWithStructExpression_01()
+        {
+            string source = @"
+struct S : System.IAsyncDisposable
+{
+    public static async System.Threading.Tasks.Task Main()
+    {
+        await using (new S())
+        {
+            System.Console.Write(""body "");
+            return;
+        }
+    }
+    System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()
+    {
+        System.Console.Write(""DisposeAsync"");
+        return new System.Threading.Tasks.ValueTask(System.Threading.Tasks.Task.CompletedTask);
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe);
+            comp.VerifyDiagnostics();
+            var verifier = CompileAndVerify(comp, expectedOutput: "body DisposeAsync");
+            verifier.VerifyIL("S.<Main>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+{
+  // Code size      298 (0x12a)
+  .maxstack  3
+  .locals init (int V_0,
+                object V_1,
+                System.Runtime.CompilerServices.ValueTaskAwaiter V_2,
+                System.Threading.Tasks.ValueTask V_3,
+                S.<Main>d__0 V_4,
+                System.Exception V_5,
+                int V_6)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int S.<Main>d__0.<>1__state""
+  IL_0006:  stloc.0
+  .try
+  {
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_000c
+    IL_000a:  br.s       IL_0011
+    IL_000c:  br         IL_0098
+    IL_0011:  nop
+    IL_0012:  ldarg.0
+    IL_0013:  ldflda     ""S S.<Main>d__0.<>s__1""
+    IL_0018:  initobj    ""S""
+    IL_001e:  ldarg.0
+    IL_001f:  ldnull
+    IL_0020:  stfld      ""object S.<Main>d__0.<>s__2""
+    IL_0025:  ldarg.0
+    IL_0026:  ldc.i4.0
+    IL_0027:  stfld      ""int S.<Main>d__0.<>s__3""
+    .try
+    {
+      IL_002c:  nop
+      IL_002d:  ldstr      ""body ""
+      IL_0032:  call       ""void System.Console.Write(string)""
+      IL_0037:  nop
+      IL_0038:  br.s       IL_003a
+      IL_003a:  ldarg.0
+      IL_003b:  ldc.i4.1
+      IL_003c:  stfld      ""int S.<Main>d__0.<>s__3""
+      IL_0041:  leave.s    IL_004d
+    }
+    catch object
+    {
+      IL_0043:  stloc.1
+      IL_0044:  ldarg.0
+      IL_0045:  ldloc.1
+      IL_0046:  stfld      ""object S.<Main>d__0.<>s__2""
+      IL_004b:  leave.s    IL_004d
+    }
+    IL_004d:  ldarg.0
+    IL_004e:  ldflda     ""S S.<Main>d__0.<>s__1""
+    IL_0053:  constrained. ""S""
+    IL_0059:  callvirt   ""System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()""
+    IL_005e:  stloc.3
+    IL_005f:  ldloca.s   V_3
+    IL_0061:  call       ""System.Runtime.CompilerServices.ValueTaskAwaiter System.Threading.Tasks.ValueTask.GetAwaiter()""
+    IL_0066:  stloc.2
+    IL_0067:  ldloca.s   V_2
+    IL_0069:  call       ""bool System.Runtime.CompilerServices.ValueTaskAwaiter.IsCompleted.get""
+    IL_006e:  brtrue.s   IL_00b4
     IL_0070:  ldarg.0
     IL_0071:  ldc.i4.0
     IL_0072:  dup
@@ -1364,6 +1838,174 @@ .locals init (int V_0,
 }");
         }
 
+        [Fact]
+        public void TestWithStructExpression_02()
+        {
+            string source = @"
+struct S : System.IAsyncDisposable
+{
+    public static async System.Threading.Tasks.Task Main()
+    {
+        await using (new S())
+        {
+            System.Console.Write(""body "");
+            return;
+        }
+    }
+    public System.Threading.Tasks.ValueTask DisposeAsync()
+    {
+        System.Console.Write(""DisposeAsync"");
+        return new System.Threading.Tasks.ValueTask(System.Threading.Tasks.Task.CompletedTask);
+    }
+}
+";
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe);
+            comp.VerifyDiagnostics();
+            var verifier = CompileAndVerify(comp, expectedOutput: "body DisposeAsync");
+            verifier.VerifyIL("S.<Main>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+{
+  // Code size      292 (0x124)
+  .maxstack  3
+  .locals init (int V_0,
+                object V_1,
+                System.Runtime.CompilerServices.ValueTaskAwaiter V_2,
+                System.Threading.Tasks.ValueTask V_3,
+                S.<Main>d__0 V_4,
+                System.Exception V_5,
+                int V_6)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int S.<Main>d__0.<>1__state""
+  IL_0006:  stloc.0
+  .try
+  {
+    IL_0007:  ldloc.0
+    IL_0008:  brfalse.s  IL_000c
+    IL_000a:  br.s       IL_0011
+    IL_000c:  br         IL_0092
+    IL_0011:  nop
+    IL_0012:  ldarg.0
+    IL_0013:  ldflda     ""S S.<Main>d__0.<>s__1""
+    IL_0018:  initobj    ""S""
+    IL_001e:  ldarg.0
+    IL_001f:  ldnull
+    IL_0020:  stfld      ""object S.<Main>d__0.<>s__2""
+    IL_0025:  ldarg.0
+    IL_0026:  ldc.i4.0
+    IL_0027:  stfld      ""int S.<Main>d__0.<>s__3""
+    .try
+    {
+      IL_002c:  nop
+      IL_002d:  ldstr      ""body ""
+      IL_0032:  call       ""void System.Console.Write(string)""
+      IL_0037:  nop
+      IL_0038:  br.s       IL_003a
+      IL_003a:  ldarg.0
+      IL_003b:  ldc.i4.1
+      IL_003c:  stfld      ""int S.<Main>d__0.<>s__3""
+      IL_0041:  leave.s    IL_004d
+    }
+    catch object
+    {
+      IL_0043:  stloc.1
+      IL_0044:  ldarg.0
+      IL_0045:  ldloc.1
+      IL_0046:  stfld      ""object S.<Main>d__0.<>s__2""
+      IL_004b:  leave.s    IL_004d
+    }
+    IL_004d:  ldarg.0
+    IL_004e:  ldflda     ""S S.<Main>d__0.<>s__1""
+    IL_0053:  call       ""System.Threading.Tasks.ValueTask S.DisposeAsync()""
+    IL_0058:  stloc.3
+    IL_0059:  ldloca.s   V_3
+    IL_005b:  call       ""System.Runtime.CompilerServices.ValueTaskAwaiter System.Threading.Tasks.ValueTask.GetAwaiter()""
+    IL_0060:  stloc.2
+    IL_0061:  ldloca.s   V_2
+    IL_0063:  call       ""bool System.Runtime.CompilerServices.ValueTaskAwaiter.IsCompleted.get""
+    IL_0068:  brtrue.s   IL_00ae
+    IL_006a:  ldarg.0
+    IL_006b:  ldc.i4.0
+    IL_006c:  dup
+    IL_006d:  stloc.0
+    IL_006e:  stfld      ""int S.<Main>d__0.<>1__state""
+    IL_0073:  ldarg.0
+    IL_0074:  ldloc.2
+    IL_0075:  stfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter S.<Main>d__0.<>u__1""
+    IL_007a:  ldarg.0
+    IL_007b:  stloc.s    V_4
+    IL_007d:  ldarg.0
+    IL_007e:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder S.<Main>d__0.<>t__builder""
+    IL_0083:  ldloca.s   V_2
+    IL_0085:  ldloca.s   V_4
+    IL_0087:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.ValueTaskAwaiter, S.<Main>d__0>(ref System.Runtime.CompilerServices.ValueTaskAwaiter, ref S.<Main>d__0)""
+    IL_008c:  nop
+    IL_008d:  leave      IL_0123
+    IL_0092:  ldarg.0
+    IL_0093:  ldfld      ""System.Runtime.CompilerServices.ValueTaskAwaiter S.<Main>d__0.<>u__1""
+    IL_0098:  stloc.2
+    IL_0099:  ldarg.0
+    IL_009a:  ldflda     ""System.Runtime.CompilerServices.ValueTaskAwaiter S.<Main>d__0.<>u__1""
+    IL_009f:  initobj    ""System.Runtime.CompilerServices.ValueTaskAwaiter""
+    IL_00a5:  ldarg.0
+    IL_00a6:  ldc.i4.m1
+    IL_00a7:  dup
+    IL_00a8:  stloc.0
+    IL_00a9:  stfld      ""int S.<Main>d__0.<>1__state""
+    IL_00ae:  ldloca.s   V_2
+    IL_00b0:  call       ""void System.Runtime.CompilerServices.ValueTaskAwaiter.GetResult()""
+    IL_00b5:  nop
+    IL_00b6:  ldarg.0
+    IL_00b7:  ldfld      ""object S.<Main>d__0.<>s__2""
+    IL_00bc:  stloc.1
+    IL_00bd:  ldloc.1
+    IL_00be:  brfalse.s  IL_00db
+    IL_00c0:  ldloc.1
+    IL_00c1:  isinst     ""System.Exception""
+    IL_00c6:  stloc.s    V_5
+    IL_00c8:  ldloc.s    V_5
+    IL_00ca:  brtrue.s   IL_00ce
+    IL_00cc:  ldloc.1
+    IL_00cd:  throw
+    IL_00ce:  ldloc.s    V_5
+    IL_00d0:  call       ""System.Runtime.ExceptionServices.ExceptionDispatchInfo System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(System.Exception)""
+    IL_00d5:  callvirt   ""void System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()""
+    IL_00da:  nop
+    IL_00db:  ldarg.0
+    IL_00dc:  ldfld      ""int S.<Main>d__0.<>s__3""
+    IL_00e1:  stloc.s    V_6
+    IL_00e3:  ldloc.s    V_6
+    IL_00e5:  ldc.i4.1
+    IL_00e6:  beq.s      IL_00ea
+    IL_00e8:  br.s       IL_00ec
+    IL_00ea:  leave.s    IL_010f
+    IL_00ec:  ldarg.0
+    IL_00ed:  ldnull
+    IL_00ee:  stfld      ""object S.<Main>d__0.<>s__2""
+    IL_00f3:  leave.s    IL_010f
+  }
+  catch System.Exception
+  {
+    IL_00f5:  stloc.s    V_5
+    IL_00f7:  ldarg.0
+    IL_00f8:  ldc.i4.s   -2
+    IL_00fa:  stfld      ""int S.<Main>d__0.<>1__state""
+    IL_00ff:  ldarg.0
+    IL_0100:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder S.<Main>d__0.<>t__builder""
+    IL_0105:  ldloc.s    V_5
+    IL_0107:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetException(System.Exception)""
+    IL_010c:  nop
+    IL_010d:  leave.s    IL_0123
+  }
+  IL_010f:  ldarg.0
+  IL_0110:  ldc.i4.s   -2
+  IL_0112:  stfld      ""int S.<Main>d__0.<>1__state""
+  IL_0117:  ldarg.0
+  IL_0118:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder S.<Main>d__0.<>t__builder""
+  IL_011d:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetResult()""
+  IL_0122:  nop
+  IL_0123:  ret
+}");
+        }
+
         [Fact]
         public void Struct_ExplicitImplementation()
         {
@@ -1833,12 +2475,9 @@ public async System.Threading.Tasks.ValueTask DisposeAsync()
 
         [Fact]
         [WorkItem(32316, "https://github.com/dotnet/roslyn/issues/32316")]
-        public void TestPatternBasedDisposal_InterfacePreferredOverInstanceMethod()
+        [WorkItem("https://github.com/dotnet/roslyn/issues/72573")]
+        public void TestPatternBasedDisposal_InterfaceNotPreferredOverInstanceMethod()
         {
-            // SPEC: In the situation where a type can be implicitly converted to IDisposable and also fits the disposable pattern,
-            // then IDisposable will be preferred.
-            // https://github.com/dotnet/csharplang/blob/main/proposals/csharp-8.0/using.md#pattern-based-using
-
             string source = @"
 public class C : System.IAsyncDisposable
 {
@@ -1852,14 +2491,14 @@ public static async System.Threading.Tasks.Task<int> Main()
         System.Console.Write(""return"");
         return 1;
     }
-    async System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()
+    System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()
+        => throw null;
+    public async System.Threading.Tasks.ValueTask DisposeAsync()
     {
         System.Console.Write($""dispose_start "");
         await System.Threading.Tasks.Task.Yield();
         System.Console.Write($""dispose_end "");
     }
-    public System.Threading.Tasks.ValueTask DisposeAsync()
-        => throw null;
 }
 ";
             var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition }, options: TestOptions.DebugExe);
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenUsingDeclarationTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenUsingDeclarationTests.cs
index 5f9ec11066ab2..eeb219d30cbc1 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenUsingDeclarationTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenUsingDeclarationTests.cs
@@ -1320,14 +1320,14 @@ static async Task Main()
         }
 
         [Fact]
-        public void UsingDeclarationAsyncMissingValueTask()
+        public void UsingDeclarationAsyncMissingValueTask_01()
         {
             var source = @"
 using System;
 using System.Threading.Tasks;
 class C1 : IAsyncDisposable
 {
-    public ValueTask DisposeAsync() 
+    ValueTask IAsyncDisposable.DisposeAsync() 
     { 
         return new ValueTask(Task.CompletedTask);
     }
@@ -1350,6 +1350,33 @@ static async Task Main()
                 );
         }
 
+        [Fact]
+        public void UsingDeclarationAsyncMissingValueTask_02()
+        {
+            var source = @"
+using System;
+using System.Threading.Tasks;
+class C1 : IAsyncDisposable
+{
+    public ValueTask DisposeAsync() 
+    { 
+        return new ValueTask(Task.CompletedTask);
+    }
+}
+
+class C2
+{
+    static async Task Main()
+    {
+        await using C1 c1 = new C1();
+    }
+}";
+
+            var comp = CreateCompilationWithTasksExtensions(new[] { source, IAsyncDisposableDefinition });
+            comp.MakeTypeMissing(WellKnownType.System_Threading_Tasks_ValueTask);
+            comp.VerifyEmitDiagnostics();
+        }
+
         [Fact]
         public void UsingDeclarationAsync_WithOptionalParameter()
         {
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUsingStatement.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUsingStatement.cs
index f50818c83dbbd..766404d3df5d2 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUsingStatement.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IUsingStatement.cs
@@ -93,7 +93,7 @@ public static async Task M1(IAsyncDisposable disposable)
 }
 ";
             string expectedOperationTree = @"
-IUsingOperation (IsAsynchronous) (OperationKind.Using, Type: null) (Syntax: 'await using ... }')
+IUsingOperation (IsAsynchronous) (DisposeMethod: System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()) (OperationKind.Using, Type: null) (Syntax: 'await using ... }')
   Locals: Local_1: System.IAsyncDisposable c
   Resources: 
     IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null, IsImplicit) (Syntax: 'var c = disposable')
@@ -126,6 +126,124 @@ public static async Task M1(IAsyncDisposable disposable)
             VerifyOperationTreeAndDiagnosticsForTest<UsingStatementSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedOperationTree, expectedDiagnostics);
         }
 
+        [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.AsyncStreams)]
+        [Fact, WorkItem(30362, "https://github.com/dotnet/roslyn/issues/30362")]
+        public void IUsingAwaitStatement_SimpleAwaitUsing_PatternBased()
+        {
+            string source = @"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{
+    public async Task M1()
+    {
+        /*<bind>*/await using (var c = this)
+        {
+            Console.WriteLine(c.ToString());
+        }/*</bind>*/
+    }
+
+    public async System.Threading.Tasks.ValueTask DisposeAsync()
+    {
+        await Task.Yield();
+    }
+}
+";
+            string expectedOperationTree = @"
+IUsingOperation (IsAsynchronous) (DisposeMethod: System.Threading.Tasks.ValueTask C.DisposeAsync()) (OperationKind.Using, Type: null) (Syntax: 'await using ... }')
+  Locals: Local_1: C c
+  Resources:
+    IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null, IsImplicit) (Syntax: 'var c = this')
+      IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'var c = this')
+        Declarators:
+            IVariableDeclaratorOperation (Symbol: C c) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'c = this')
+              Initializer:
+                IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= this')
+                  IInstanceReferenceOperation (ReferenceKind: ContainingTypeInstance) (OperationKind.InstanceReference, Type: C) (Syntax: 'this')
+        Initializer:
+          null
+  Body:
+    IBlockOperation (1 statements) (OperationKind.Block, Type: null) (Syntax: '{ ... }')
+      IExpressionStatementOperation (OperationKind.ExpressionStatement, Type: null) (Syntax: 'Console.Wri ... oString());')
+        Expression:
+          IInvocationOperation (void System.Console.WriteLine(System.String value)) (OperationKind.Invocation, Type: System.Void) (Syntax: 'Console.Wri ... ToString())')
+            Instance Receiver:
+              null
+            Arguments(1):
+                IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument, Type: null) (Syntax: 'c.ToString()')
+                  IInvocationOperation (virtual System.String System.Object.ToString()) (OperationKind.Invocation, Type: System.String) (Syntax: 'c.ToString()')
+                    Instance Receiver:
+                      ILocalReferenceOperation: c (OperationKind.LocalReference, Type: C) (Syntax: 'c')
+                    Arguments(0)
+                  InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+";
+
+            var expectedDiagnostics = DiagnosticDescription.None;
+            VerifyOperationTreeAndDiagnosticsForTest<UsingStatementSyntax>(source + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedOperationTree, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.AsyncStreams)]
+        [Fact, WorkItem(30362, "https://github.com/dotnet/roslyn/issues/30362")]
+        public void IUsingAwaitStatement_SimpleAwaitUsing_InterfaceBased()
+        {
+            string source = @"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C : IAsyncDisposable
+{
+    public async Task M1()
+    {
+        /*<bind>*/await using (var c = this)
+        {
+            Console.WriteLine(c.ToString());
+        }/*</bind>*/
+    }
+
+    async ValueTask IAsyncDisposable.DisposeAsync()
+    {
+        await Task.Yield();
+    }
+}
+";
+            string expectedOperationTree = @"
+IUsingOperation (IsAsynchronous) (OperationKind.Using, Type: null) (Syntax: 'await using ... }')
+  Locals: Local_1: C c
+  Resources:
+    IVariableDeclarationGroupOperation (1 declarations) (OperationKind.VariableDeclarationGroup, Type: null, IsImplicit) (Syntax: 'var c = this')
+      IVariableDeclarationOperation (1 declarators) (OperationKind.VariableDeclaration, Type: null) (Syntax: 'var c = this')
+        Declarators:
+            IVariableDeclaratorOperation (Symbol: C c) (OperationKind.VariableDeclarator, Type: null) (Syntax: 'c = this')
+              Initializer:
+                IVariableInitializerOperation (OperationKind.VariableInitializer, Type: null) (Syntax: '= this')
+                  IInstanceReferenceOperation (ReferenceKind: ContainingTypeInstance) (OperationKind.InstanceReference, Type: C) (Syntax: 'this')
+        Initializer:
+          null
+  Body:
+    IBlockOperation (1 statements) (OperationKind.Block, Type: null) (Syntax: '{ ... }')
+      IExpressionStatementOperation (OperationKind.ExpressionStatement, Type: null) (Syntax: 'Console.Wri ... oString());')
+        Expression:
+          IInvocationOperation (void System.Console.WriteLine(System.String value)) (OperationKind.Invocation, Type: System.Void) (Syntax: 'Console.Wri ... ToString())')
+            Instance Receiver:
+              null
+            Arguments(1):
+                IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument, Type: null) (Syntax: 'c.ToString()')
+                  IInvocationOperation (virtual System.String System.Object.ToString()) (OperationKind.Invocation, Type: System.String) (Syntax: 'c.ToString()')
+                    Instance Receiver:
+                      ILocalReferenceOperation: c (OperationKind.LocalReference, Type: C) (Syntax: 'c')
+                    Arguments(0)
+                  InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+";
+
+            var expectedDiagnostics = DiagnosticDescription.None;
+            VerifyOperationTreeAndDiagnosticsForTest<UsingStatementSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedOperationTree, expectedDiagnostics);
+        }
+
         [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow, CompilerFeature.AsyncStreams)]
         [Fact, WorkItem(30362, "https://github.com/dotnet/roslyn/issues/30362")]
         public void UsingFlow_SimpleAwaitUsing()
@@ -159,9 +277,9 @@ public static async Task M1(IAsyncDisposable disposable)
         Predecessors: [B0]
         Statements (1)
             ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.IAsyncDisposable, IsImplicit) (Syntax: 'c = disposable')
-              Left: 
+              Left:
                 ILocalReferenceOperation: c (IsDeclaration: True) (OperationKind.LocalReference, Type: System.IAsyncDisposable, IsImplicit) (Syntax: 'c = disposable')
-              Right: 
+              Right:
                 IParameterReferenceOperation: disposable (OperationKind.ParameterReference, Type: System.IAsyncDisposable) (Syntax: 'disposable')
         Next (Regular) Block[B2]
             Entering: {R2} {R3}
@@ -171,14 +289,14 @@ public static async Task M1(IAsyncDisposable disposable)
             Predecessors: [B1]
             Statements (1)
                 IExpressionStatementOperation (OperationKind.ExpressionStatement, Type: null) (Syntax: 'Console.Wri ... oString());')
-                  Expression: 
+                  Expression:
                     IInvocationOperation (void System.Console.WriteLine(System.String value)) (OperationKind.Invocation, Type: System.Void) (Syntax: 'Console.Wri ... ToString())')
-                      Instance Receiver: 
+                      Instance Receiver:
                         null
                       Arguments(1):
                           IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument, Type: null) (Syntax: 'c.ToString()')
                             IInvocationOperation (virtual System.String System.Object.ToString()) (OperationKind.Invocation, Type: System.String) (Syntax: 'c.ToString()')
-                              Instance Receiver: 
+                              Instance Receiver:
                                 ILocalReferenceOperation: c (OperationKind.LocalReference, Type: System.IAsyncDisposable) (Syntax: 'c')
                               Arguments(0)
                             InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
@@ -194,16 +312,16 @@ public static async Task M1(IAsyncDisposable disposable)
             Statements (0)
             Jump if True (Regular) to Block[B5]
                 IIsNullOperation (OperationKind.IsNull, Type: System.Boolean, IsImplicit) (Syntax: 'c = disposable')
-                  Operand: 
+                  Operand:
                     ILocalReferenceOperation: c (OperationKind.LocalReference, Type: System.IAsyncDisposable, IsImplicit) (Syntax: 'c = disposable')
             Next (Regular) Block[B4]
         Block[B4] - Block
             Predecessors: [B3]
             Statements (1)
                 IAwaitOperation (OperationKind.Await, Type: System.Void, IsImplicit) (Syntax: 'c = disposable')
-                  Expression: 
-                    IInvocationOperation (virtual System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()) (OperationKind.Invocation, Type: System.Threading.Tasks.ValueTask, IsImplicit) (Syntax: 'c = disposable')
-                      Instance Receiver: 
+                  Expression:
+                    IInvocationOperation ( System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()) (OperationKind.Invocation, Type: System.Threading.Tasks.ValueTask, IsImplicit) (Syntax: 'c = disposable')
+                      Instance Receiver:
                         ILocalReferenceOperation: c (OperationKind.LocalReference, Type: System.IAsyncDisposable, IsImplicit) (Syntax: 'c = disposable')
                       Arguments(0)
             Next (Regular) Block[B5]
@@ -222,6 +340,212 @@ public static async Task M1(IAsyncDisposable disposable)
             VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
         }
 
+        [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow, CompilerFeature.AsyncStreams)]
+        [Fact, WorkItem(30362, "https://github.com/dotnet/roslyn/issues/30362")]
+        public void UsingFlow_SimpleAwaitUsing_PatternBased()
+        {
+            string source = @"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C
+{
+    public async Task M1()
+    /*<bind>*/{
+        await using (var c = this)
+        {
+            Console.WriteLine(c.ToString());
+        }
+    }/*</bind>*/
+
+    public async ValueTask DisposeAsync()
+    {
+        await System.Threading.Tasks.Task.Yield();
+    }
+}
+";
+
+            string expectedGraph = @"
+Block[B0] - Entry
+    Statements (0)
+    Next (Regular) Block[B1]
+        Entering: {R1}
+.locals {R1}
+{
+    Locals: [C c]
+    Block[B1] - Block
+        Predecessors: [B0]
+        Statements (1)
+            ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: C, IsImplicit) (Syntax: 'c = this')
+              Left:
+                ILocalReferenceOperation: c (IsDeclaration: True) (OperationKind.LocalReference, Type: C, IsImplicit) (Syntax: 'c = this')
+              Right:
+                IInstanceReferenceOperation (ReferenceKind: ContainingTypeInstance) (OperationKind.InstanceReference, Type: C) (Syntax: 'this')
+        Next (Regular) Block[B2]
+            Entering: {R2} {R3}
+    .try {R2, R3}
+    {
+        Block[B2] - Block
+            Predecessors: [B1]
+            Statements (1)
+                IExpressionStatementOperation (OperationKind.ExpressionStatement, Type: null) (Syntax: 'Console.Wri ... oString());')
+                  Expression:
+                    IInvocationOperation (void System.Console.WriteLine(System.String value)) (OperationKind.Invocation, Type: System.Void) (Syntax: 'Console.Wri ... ToString())')
+                      Instance Receiver:
+                        null
+                      Arguments(1):
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument, Type: null) (Syntax: 'c.ToString()')
+                            IInvocationOperation (virtual System.String System.Object.ToString()) (OperationKind.Invocation, Type: System.String) (Syntax: 'c.ToString()')
+                              Instance Receiver:
+                                ILocalReferenceOperation: c (OperationKind.LocalReference, Type: C) (Syntax: 'c')
+                              Arguments(0)
+                            InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                            OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+            Next (Regular) Block[B6]
+                Finalizing: {R4}
+                Leaving: {R3} {R2} {R1}
+    }
+    .finally {R4}
+    {
+        Block[B3] - Block
+            Predecessors (0)
+            Statements (0)
+            Jump if True (Regular) to Block[B5]
+                IIsNullOperation (OperationKind.IsNull, Type: System.Boolean, IsImplicit) (Syntax: 'c = this')
+                  Operand:
+                    ILocalReferenceOperation: c (OperationKind.LocalReference, Type: C, IsImplicit) (Syntax: 'c = this')
+            Next (Regular) Block[B4]
+        Block[B4] - Block
+            Predecessors: [B3]
+            Statements (1)
+                IAwaitOperation (OperationKind.Await, Type: System.Void, IsImplicit) (Syntax: 'c = this')
+                  Expression:
+                    IInvocationOperation ( System.Threading.Tasks.ValueTask C.DisposeAsync()) (OperationKind.Invocation, Type: System.Threading.Tasks.ValueTask, IsImplicit) (Syntax: 'c = this')
+                      Instance Receiver:
+                        ILocalReferenceOperation: c (OperationKind.LocalReference, Type: C, IsImplicit) (Syntax: 'c = this')
+                      Arguments(0)
+            Next (Regular) Block[B5]
+        Block[B5] - Block
+            Predecessors: [B3] [B4]
+            Statements (0)
+            Next (StructuredExceptionHandling) Block[null]
+    }
+}
+Block[B6] - Exit
+    Predecessors: [B2]
+    Statements (0)
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
+        }
+
+        [CompilerTrait(CompilerFeature.IOperation, CompilerFeature.Dataflow, CompilerFeature.AsyncStreams)]
+        [Fact, WorkItem(30362, "https://github.com/dotnet/roslyn/issues/30362")]
+        public void UsingFlow_SimpleAwaitUsing_InterfaceBased()
+        {
+            string source = @"
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+class C : IAsyncDisposable
+{
+    public async Task M1()
+    /*<bind>*/{
+        await using (var c = this)
+        {
+            Console.WriteLine(c.ToString());
+        }
+    }/*</bind>*/
+
+    async ValueTask IAsyncDisposable.DisposeAsync()
+    {
+        await System.Threading.Tasks.Task.Yield();
+    }
+}
+";
+
+            string expectedGraph = @"
+Block[B0] - Entry
+    Statements (0)
+    Next (Regular) Block[B1]
+        Entering: {R1}
+.locals {R1}
+{
+    Locals: [C c]
+    Block[B1] - Block
+        Predecessors: [B0]
+        Statements (1)
+            ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: C, IsImplicit) (Syntax: 'c = this')
+              Left:
+                ILocalReferenceOperation: c (IsDeclaration: True) (OperationKind.LocalReference, Type: C, IsImplicit) (Syntax: 'c = this')
+              Right:
+                IInstanceReferenceOperation (ReferenceKind: ContainingTypeInstance) (OperationKind.InstanceReference, Type: C) (Syntax: 'this')
+        Next (Regular) Block[B2]
+            Entering: {R2} {R3}
+    .try {R2, R3}
+    {
+        Block[B2] - Block
+            Predecessors: [B1]
+            Statements (1)
+                IExpressionStatementOperation (OperationKind.ExpressionStatement, Type: null) (Syntax: 'Console.Wri ... oString());')
+                  Expression:
+                    IInvocationOperation (void System.Console.WriteLine(System.String value)) (OperationKind.Invocation, Type: System.Void) (Syntax: 'Console.Wri ... ToString())')
+                      Instance Receiver:
+                        null
+                      Arguments(1):
+                          IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument, Type: null) (Syntax: 'c.ToString()')
+                            IInvocationOperation (virtual System.String System.Object.ToString()) (OperationKind.Invocation, Type: System.String) (Syntax: 'c.ToString()')
+                              Instance Receiver:
+                                ILocalReferenceOperation: c (OperationKind.LocalReference, Type: C) (Syntax: 'c')
+                              Arguments(0)
+                            InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                            OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+            Next (Regular) Block[B6]
+                Finalizing: {R4}
+                Leaving: {R3} {R2} {R1}
+    }
+    .finally {R4}
+    {
+        Block[B3] - Block
+            Predecessors (0)
+            Statements (0)
+            Jump if True (Regular) to Block[B5]
+                IIsNullOperation (OperationKind.IsNull, Type: System.Boolean, IsImplicit) (Syntax: 'c = this')
+                  Operand:
+                    ILocalReferenceOperation: c (OperationKind.LocalReference, Type: C, IsImplicit) (Syntax: 'c = this')
+            Next (Regular) Block[B4]
+        Block[B4] - Block
+            Predecessors: [B3]
+            Statements (1)
+                IAwaitOperation (OperationKind.Await, Type: System.Void, IsImplicit) (Syntax: 'c = this')
+                  Expression:
+                    IInvocationOperation (virtual System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()) (OperationKind.Invocation, Type: System.Threading.Tasks.ValueTask, IsImplicit) (Syntax: 'c = this')
+                      Instance Receiver:
+                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.IAsyncDisposable, IsImplicit) (Syntax: 'c = this')
+                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: True, IsUserDefined: False) (MethodSymbol: null)
+                            (ImplicitReference)
+                          Operand:
+                            ILocalReferenceOperation: c (OperationKind.LocalReference, Type: C, IsImplicit) (Syntax: 'c = this')
+                      Arguments(0)
+            Next (Regular) Block[B5]
+        Block[B5] - Block
+            Predecessors: [B3] [B4]
+            Statements (0)
+            Next (StructuredExceptionHandling) Block[null]
+    }
+}
+Block[B6] - Exit
+    Predecessors: [B2]
+    Statements (0)
+";
+            var expectedDiagnostics = DiagnosticDescription.None;
+
+            VerifyFlowGraphAndDiagnosticsForTest<BlockSyntax>(source + s_IAsyncEnumerable + IOperationTests_IForEachLoopStatement.s_ValueTask, expectedGraph, expectedDiagnostics);
+        }
+
         [CompilerTrait(CompilerFeature.IOperation)]
         [Fact]
         public void IUsingStatement_MultipleNewVariable()
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/UsingDeclarationTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/UsingDeclarationTests.cs
index 7646942ebd539..da09f7cdd28d2 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/UsingDeclarationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/UsingDeclarationTests.cs
@@ -867,7 +867,10 @@ static async Task Main()
 ";
             var expected = new[]
             {
-                // (8,15): error CS8652: The feature 'using declarations' is not available in C# 7.3. Please use language version 8.0 or greater.
+                // 0.cs(8,9): error CS8370: Feature 'pattern-based disposal' is not available in C# 7.3. Please use language version 8.0 or greater.
+                //         await using IAsyncDisposable x = null;
+                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "await using IAsyncDisposable x = null;").WithArguments("pattern-based disposal", "8.0").WithLocation(8, 9),
+                // 0.cs(8,15): error CS8370: Feature 'using declarations' is not available in C# 7.3. Please use language version 8.0 or greater.
                 //         await using IAsyncDisposable x = null;
                 Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "using").WithArguments("using declarations", "8.0").WithLocation(8, 15)
             };

From 35aea351e93d1b822b2744e137602723d565f49e Mon Sep 17 00:00:00 2001
From: Jared Parsons <jared@paranoidcoding.org>
Date: Thu, 21 Mar 2024 11:35:49 -0700
Subject: [PATCH 170/170] Replay Binary Log Tool (#72619)

This adds a tool for replaying compilation events from binary logs directly to the compiler server. This is an effective tool for profiling the compiler server as it removes MSBuild overhead from the logs leaving just the compiler.

Further because it's integrated into our code base it makes it very easy to evaluate the efficacy of performance fixes. One simply needs to run `replay` with and without the changes against the same binary log and evaluate the differences in perfview.
---
 .vscode/launch.json                           |  12 +
 .vscode/tasks.json                            |  11 +-
 Compilers.slnf                                |   1 +
 Roslyn.sln                                    |  12 +
 eng/Directory.Packages.props                  |   3 +-
 .../Core/CommandLine/CompilerServerLogger.cs  |  15 +-
 src/Compilers/Shared/BuildServerConnection.cs |   2 +-
 src/Tools/Replay/README.md                    |  26 ++
 src/Tools/Replay/Replay.cs                    | 274 ++++++++++++++++++
 src/Tools/Replay/Replay.csproj                |  36 +++
 10 files changed, 374 insertions(+), 18 deletions(-)
 create mode 100644 src/Tools/Replay/README.md
 create mode 100644 src/Tools/Replay/Replay.cs
 create mode 100644 src/Tools/Replay/Replay.csproj

diff --git a/.vscode/launch.json b/.vscode/launch.json
index 1f4bb8c58fe88..f7da4782cb89a 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -50,6 +50,18 @@
       "stopAtEntry": false,
       "console": "internalConsole"
     },
+    {
+      "name": "Launch Replay.dll",
+      "type": "coreclr",
+      "request": "launch",
+      "preLaunchTask": "build current project",
+      // If you have changed target frameworks, make sure to update the program path.
+      "program": "${workspaceFolder}/artifacts/bin/Replay/Debug/net8.0/Replay.dll",
+      "args": [],
+      "cwd": "${workspaceFolder}/artifacts/bin/Replay",
+      "stopAtEntry": false,
+      "console": "internalConsole"
+    },
     {
       "name": ".NET Core Launch (console)",
       "type": "coreclr",
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 79e00ef37e4c9..f85f5cc650b82 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -73,22 +73,13 @@
         "command": "dotnet",
         "args": [
           "pwsh",
+          "-noprofile",
           "${workspaceFolder}/scripts/vscode-build.ps1",
           "-filePath",
           "${file}",
           "-msbuildEngine",
           "dotnet"
         ],
-        "windows": {
-          "command": "powershell",
-          "args": [
-            "${workspaceFolder}/scripts/vscode-build.ps1",
-            "-filePath",
-            "${file}",
-            "-msbuildEngine",
-            "dotnet"
-          ],
-        },
         "problemMatcher": "$msCompile",
         "group": "build"
     },
diff --git a/Compilers.slnf b/Compilers.slnf
index fece22f528bfd..04ccd49c2c5a2 100644
--- a/Compilers.slnf
+++ b/Compilers.slnf
@@ -64,6 +64,7 @@
       "src\\Scripting\\VisualBasic\\Microsoft.CodeAnalysis.VisualBasic.Scripting.vbproj",
       "src\\Test\\PdbUtilities\\Roslyn.Test.PdbUtilities.csproj",
       "src\\Tools\\BuildBoss\\BuildBoss.csproj",
+      "src\\Tools\\Replay\\Replay.csproj",
       "src\\Tools\\BuildValidator\\BuildValidator.csproj",
       "src\\Tools\\PrepareTests\\PrepareTests.csproj",
       "src\\Tools\\Source\\CompilerGeneratorTools\\Source\\BoundTreeGenerator\\CompilersBoundTreeGenerator.csproj",
diff --git a/Roslyn.sln b/Roslyn.sln
index df9b1302453dd..9492f8eeb33b2 100644
--- a/Roslyn.sln
+++ b/Roslyn.sln
@@ -544,6 +544,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Feat
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.Features.Test.Utilities", "src\Features\TestUtilities\Microsoft.CodeAnalysis.Features.Test.Utilities.csproj", "{5762E483-75CE-4328-A410-511F30737712}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{0F3118AE-8D36-4384-8E80-BD6566365305}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tools", "Tools", "{47D004BE-F797-430E-8A18-4B0CDFD56643}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Replay", "src\Tools\Replay\Replay.csproj", "{DB96C25F-39A9-4A6A-92BC-D1E42717308F}"
+EndProject
 Project("{D954291E-2A0B-460D-934E-DC6B0785DB48}") = "Microsoft.CommonLanguageServerProtocol.Framework.Shared", "src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\Microsoft.CommonLanguageServerProtocol.Framework.Shared.shproj", "{64EADED3-4B5D-4431-BBE5-A4ABA1C38C00}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CommonLanguageServerProtocol.Framework.Binary", "src\Features\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework.Binary\Microsoft.CommonLanguageServerProtocol.Framework.Binary.csproj", "{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}"
@@ -1350,6 +1356,10 @@ Global
 		{5762E483-75CE-4328-A410-511F30737712}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5762E483-75CE-4328-A410-511F30737712}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5762E483-75CE-4328-A410-511F30737712}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DB96C25F-39A9-4A6A-92BC-D1E42717308F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DB96C25F-39A9-4A6A-92BC-D1E42717308F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DB96C25F-39A9-4A6A-92BC-D1E42717308F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DB96C25F-39A9-4A6A-92BC-D1E42717308F}.Release|Any CPU.Build.0 = Release|Any CPU
 		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -1603,6 +1613,8 @@ Global
 		{4D9D7A28-BB44-4F3F-81DA-14F39B853718} = {CC126D03-7EAC-493F-B187-DCDEE1EF6A70}
 		{5BABC440-4F1B-46E8-9068-DD7F02ED25D3} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
 		{5762E483-75CE-4328-A410-511F30737712} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
+		{47D004BE-F797-430E-8A18-4B0CDFD56643} = {0F3118AE-8D36-4384-8E80-BD6566365305}
+		{DB96C25F-39A9-4A6A-92BC-D1E42717308F} = {47D004BE-F797-430E-8A18-4B0CDFD56643}
 		{64EADED3-4B5D-4431-BBE5-A4ABA1C38C00} = {D449D505-CC6A-4E0B-AF1B-976E2D0AE67A}
 		{730CADBA-701F-4722-9B6F-1FCC0DF2C95D} = {D449D505-CC6A-4E0B-AF1B-976E2D0AE67A}
 	EndGlobalSection
diff --git a/eng/Directory.Packages.props b/eng/Directory.Packages.props
index 97b6a820a7560..ea4b42a8e1785 100644
--- a/eng/Directory.Packages.props
+++ b/eng/Directory.Packages.props
@@ -291,6 +291,7 @@
     <PackageVersion Include="runtime.win-x64.Microsoft.NETCore.ILAsm" Version="$(ILAsmPackageVersion)" />
     <PackageVersion Include="runtime.linux-x64.Microsoft.NETCore.ILAsm" Version="$(ILAsmPackageVersion)" />
     <PackageVersion Include="runtime.osx-x64.Microsoft.NETCore.ILAsm" Version="$(ILAsmPackageVersion)" />
+    <PackageVersion Include="Basic.CompilerLog.Util" Version="0.6.1" />
     <PackageVersion Include="Basic.Reference.Assemblies.NetStandard20" Version="1.2.4" />
     <PackageVersion Include="Basic.Reference.Assemblies.Net50" Version="1.2.4" />
     <PackageVersion Include="Basic.Reference.Assemblies.Net60" Version="1.2.4" />
@@ -310,7 +311,7 @@
       Infra
     -->
     <PackageVersion Include="Microsoft.Win32.Registry" Version="5.0.0" />
-    <PackageVersion Include="MSBuild.StructuredLogger" Version="2.2.158" />
+    <PackageVersion Include="MSBuild.StructuredLogger" Version="2.2.169" />
     <PackageVersion Include="Mono.Options" Version="6.6.0.161" />
     <PackageVersion Include="RichCodeNav.EnvVarDump" Version="0.1.1643-alpha" />
     <PackageVersion Include="Roslyn.Diagnostics.Analyzers" Version="$(RoslynDiagnosticsNugetPackageVersion)" />
diff --git a/src/Compilers/Core/CommandLine/CompilerServerLogger.cs b/src/Compilers/Core/CommandLine/CompilerServerLogger.cs
index d13c363c03446..b0f2a0cb0df69 100644
--- a/src/Compilers/Core/CommandLine/CompilerServerLogger.cs
+++ b/src/Compilers/Core/CommandLine/CompilerServerLogger.cs
@@ -108,26 +108,29 @@ internal sealed class CompilerServerLogger : ICompilerServerLogger, IDisposable
         /// <summary>
         /// Static class initializer that initializes logging.
         /// </summary>
-        public CompilerServerLogger(string identifier)
+        public CompilerServerLogger(string identifier, string? loggingFilePath = null)
         {
             _identifier = identifier;
 
             try
             {
-                // Check if the environment
-                if (Environment.GetEnvironmentVariable(EnvironmentVariableName) is string loggingFileName)
+                if (loggingFilePath is null)
                 {
+                    loggingFilePath = Environment.GetEnvironmentVariable(EnvironmentVariableName);
                     // If the environment variable contains the path of a currently existing directory,
                     // then use a process-specific name for the log file and put it in that directory.
                     // Otherwise, assume that the environment variable specifies the name of the log file.
-                    if (Directory.Exists(loggingFileName))
+                    if (Directory.Exists(loggingFilePath))
                     {
                         var processId = Process.GetCurrentProcess().Id;
-                        loggingFileName = Path.Combine(loggingFileName, $"server.{processId}.log");
+                        loggingFilePath = Path.Combine(loggingFilePath, $"server.{processId}.log");
                     }
+                }
 
+                if (loggingFilePath is not null)
+                {
                     // Open allowing sharing. We allow multiple processes to log to the same file, so we use share mode to allow that.
-                    _loggingStream = new FileStream(loggingFileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
+                    _loggingStream = new FileStream(loggingFilePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
                 }
             }
             catch (Exception e)
diff --git a/src/Compilers/Shared/BuildServerConnection.cs b/src/Compilers/Shared/BuildServerConnection.cs
index c858dd92b69ec..c7b1ab3fb10d0 100644
--- a/src/Compilers/Shared/BuildServerConnection.cs
+++ b/src/Compilers/Shared/BuildServerConnection.cs
@@ -446,7 +446,7 @@ internal static (string processFilePath, string commandLineArguments, string too
         /// compiler server process was successful, it does not state whether the server successfully
         /// started or not (it could crash on startup).
         /// </summary>
-        private static bool TryCreateServer(string clientDirectory, string pipeName, ICompilerServerLogger logger)
+        internal static bool TryCreateServer(string clientDirectory, string pipeName, ICompilerServerLogger logger)
         {
             var serverInfo = GetServerProcessInfo(clientDirectory, pipeName);
 
diff --git a/src/Tools/Replay/README.md b/src/Tools/Replay/README.md
new file mode 100644
index 0000000000000..9e6e6986efcdc
--- /dev/null
+++ b/src/Tools/Replay/README.md
@@ -0,0 +1,26 @@
+# Replay
+
+This is a tool for replaying the compilation events from a [binary log][binary-log] directly into the compiler server. This is very useful for profiling the compiler as it removes the overhead of msbuild from the logs. This gives a much simpler view of the compiler's performance.
+
+The other advantage is the tool allows for easy testing of performance changes to the compiler. Developers can have two branches of the code, one with performance changes and one without, then run `replay` against the same binary log and analyze the performance differences.
+
+Note: this is only supported for replaying binary logs on the same machine they were built.
+
+## Usage
+
+The first step is to run a build locally and collect a binary log. For example:
+
+```cmd
+e:\code\example> dotnet msbuild -bl -v:m -m Example.sln
+```
+
+Then run the replay tool against that log.
+
+```cmd
+e:\code\roslyn> cd src\Tools\Replay
+e:\code\roslyn\src\Tools\Replay> dotnet run --framework net472 e:\code\example\msbuild.binlog -o e:\temp
+```
+
+This runs all of the compilation events in the binary log against the compiler and outputs the results to `e:\temp`.
+
+[binary-log]: https://github.com/dotnet/msbuild/blob/main/documentation/wiki/Binary-Log.md
\ No newline at end of file
diff --git a/src/Tools/Replay/Replay.cs b/src/Tools/Replay/Replay.cs
new file mode 100644
index 0000000000000..60599f2dcdbf0
--- /dev/null
+++ b/src/Tools/Replay/Replay.cs
@@ -0,0 +1,274 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Basic.CompilerLog.Util;
+using Microsoft.CodeAnalysis.CommandLine;
+using Microsoft.CodeAnalysis.Options;
+using Mono.Options;
+
+var options = ParseOptions(args);
+if (Directory.Exists(options.OutputDirectory))
+{
+    Directory.Delete(options.OutputDirectory, recursive: true);
+}
+Directory.CreateDirectory(options.OutputDirectory);
+Directory.CreateDirectory(options.TempDirectory);
+
+return await RunAsync(options).ConfigureAwait(false);
+
+static ReplayOptions ParseOptions(string[] args)
+{
+    string? outputDirectory = null;
+    string? binlogPath = null;
+    int maxParallel = 6;
+
+    var options = new Mono.Options.OptionSet()
+    {
+        { "b|binlogPath=", "The binary log to relpay", v => binlogPath = v },
+        { "o|outputDirectory=", "The directory to output the build results", v => outputDirectory = v },
+        { "m|maxParallel=", "The maximum number of parallel builds", (int v) => maxParallel = v },
+    };
+
+    var rest = options.Parse(args);
+    if (rest.Count == 1)
+    {
+        binlogPath = rest[0];
+    }
+    else if (rest.Count > 1)
+    {
+        throw new Exception("Too many arguments");
+    }
+
+    if (string.IsNullOrEmpty(binlogPath))
+    {
+        throw new Exception("Missing binlogPath");
+    }
+
+    if (string.IsNullOrEmpty(outputDirectory))
+    {
+        outputDirectory = Path.Combine(Environment.CurrentDirectory, "output");
+    }
+
+    return new ReplayOptions(
+        pipeName: Guid.NewGuid().ToString(),
+        clientDirectory: AppDomain.CurrentDomain.BaseDirectory!,
+        outputDirectory: outputDirectory,
+        binlogPath: binlogPath,
+        maxParallel: maxParallel);
+}
+
+static async Task<int> RunAsync(ReplayOptions options)
+{
+    Console.WriteLine($"Binary Log: {options.BinlogPath}");
+    Console.WriteLine($"Client Directory: {options.ClientDirectory}");
+    Console.WriteLine($"Output Directory: {options.OutputDirectory}");
+    Console.WriteLine($"Pipe Name: {options.PipeName}");
+    Console.WriteLine($"Parallel: {options.MaxParallel}");
+    Console.WriteLine();
+    Console.WriteLine("Starting server");
+
+    using var compilerServerLogger = new CompilerServerLogger("replay", Path.Combine(options.OutputDirectory, "server.log"));
+    if (!BuildServerConnection.TryCreateServer(options.ClientDirectory, options.PipeName, compilerServerLogger))
+    {
+        Console.WriteLine("Failed to start server");
+        return 1;
+    }
+
+    try
+    {
+        var compilerCalls = ReadAllCompilerCalls(options.BinlogPath);
+        var stopwatch = new Stopwatch();
+        stopwatch.Start();
+
+        await foreach (var buildData in BuildAllAsync(options, compilerCalls, compilerServerLogger, CancellationToken.None))
+        {
+            Console.WriteLine($"{buildData.CompilerCall.GetDiagnosticName()} ... {buildData.BuildResponse.Type}");
+        }
+
+        stopwatch.Stop();
+        Console.WriteLine($"Pipe Name: {options.PipeName}");
+        Console.WriteLine($"Compilation Events: {compilerCalls.Count}");
+        Console.WriteLine($"Time: {stopwatch.Elapsed:mm\\:ss}");
+
+        return 0;
+    }
+    finally
+    {
+        Console.WriteLine("Shutting down server");
+
+        await BuildServerConnection.RunServerShutdownRequestAsync(
+            options.PipeName,
+            timeoutOverride: null,
+            waitForProcess: true,
+            compilerServerLogger,
+            cancellationToken: CancellationToken.None).ConfigureAwait(false);
+    }
+}
+
+static List<CompilerCall> ReadAllCompilerCalls(string binlogPath)
+{
+    using var stream = new FileStream(binlogPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+    return BinaryLogUtil.ReadAllCompilerCalls(stream, new List<string>());
+}
+
+static async IAsyncEnumerable<BuildData> BuildAllAsync(
+    ReplayOptions options,
+    List<CompilerCall> compilerCalls,
+    CompilerServerLogger compilerServerLogger,
+    [EnumeratorCancellation] CancellationToken cancellationToken)
+{
+    var index = 0;
+    var maxParallel = options.MaxParallel;
+    var tasks = new List<Task<BuildData>>(capacity: maxParallel);
+    var outputSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+    do
+    {
+        while (tasks.Count < maxParallel && index < compilerCalls.Count)
+        {
+            var compilerCall = compilerCalls[index];
+            tasks.Add(BuildAsync(options, compilerCall, GetOutputName(compilerCall), compilerServerLogger, cancellationToken));
+            index++;
+        }
+
+        var completedTask = await Task.WhenAny(tasks).ConfigureAwait(false);
+        if (!tasks.Remove(completedTask))
+        {
+            throw new Exception("Task was not in the list");
+        }
+
+        var buildData = await completedTask.ConfigureAwait(false);
+        yield return buildData;
+    } while (tasks.Count > 0);
+
+    string GetOutputName(CompilerCall compilerCall)
+    {
+        string name;
+        if (compilerCall.Kind is CompilerCallKind.Regular)
+        {
+            name = $"{compilerCall.ProjectFileName}-{compilerCall.TargetFramework}";
+        }
+        else
+        {
+            name = $"{compilerCall.ProjectFileName}-{compilerCall.TargetFramework}-{compilerCall.Kind}";
+        }
+
+        if (!outputSet.Add(name))
+        {
+            name = $"{name}-{outputSet.Count}";
+        }
+
+        return name;
+    }
+}
+
+static async Task<BuildData> BuildAsync(
+    ReplayOptions options,
+    CompilerCall compilerCall,
+    string outputName,
+    CompilerServerLogger compilerServerLogger,
+    CancellationToken cancellationToken)
+{
+    var args = compilerCall.GetArguments();
+    var outputDirectory = Path.Combine(options.OutputDirectory, outputName);
+    Directory.CreateDirectory(outputDirectory);
+    RewriteOutputPaths(outputDirectory, args);
+
+    var request = BuildServerConnection.CreateBuildRequest(
+        outputName,
+        compilerCall.IsCSharp ? RequestLanguage.CSharpCompile : RequestLanguage.VisualBasicCompile,
+        args.ToList(),
+        workingDirectory: compilerCall.ProjectDirectory,
+        tempDirectory: options.TempDirectory,
+        keepAlive: null,
+        libDirectory: null);
+    var response = await BuildServerConnection.RunServerBuildRequestAsync(
+        request,
+        options.PipeName,
+        options.ClientDirectory,
+        compilerServerLogger,
+        cancellationToken).ConfigureAwait(false);
+    return new BuildData(compilerCall, response);
+}
+
+static void RewriteOutputPaths(string outputDirectory, string[] args)
+{
+    var comparison = StringComparison.OrdinalIgnoreCase;
+    var hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+    for (var i = 0; i < args.Length; i++)
+    {
+        var line = args[i];
+        var isOption = line.Length > 0 && line[0] is '-' or '/';
+        if (!isOption)
+        {
+            continue;
+        }
+
+        line = line.Substring(1);
+        // Map all of the output items to the build output directory
+        if (line.StartsWith("out", comparison) ||
+            line.StartsWith("refout", comparison) ||
+            line.StartsWith("doc", comparison) ||
+            line.StartsWith("errorlog", comparison))
+        {
+            var index = line.IndexOf(':');
+            var argValue = line.AsSpan().Slice(index + 1).ToString();
+
+            string fileName;
+            if (Path.IsPathRooted(argValue))
+            {
+                fileName = Path.GetFileName(argValue);
+            }
+            else
+            {
+                fileName = argValue;
+            }
+
+            if (!hashSet.Add(fileName))
+            {
+                fileName = Path.Combine(hashSet.Count.ToString(), fileName);
+            }
+
+            var filePath = Path.Combine(outputDirectory, fileName);
+            Directory.CreateDirectory(Path.GetDirectoryName(filePath)!);
+            var argName = line.AsSpan().Slice(0, index).ToString();
+            args[i] = $"/{argName}:{filePath}";
+        }
+
+        if (line.StartsWith("generatedfilesout", comparison))
+        {
+            var generatedDir = Path.Combine(outputDirectory, "generated");
+            Directory.CreateDirectory(generatedDir);
+            args[i] = $"/generatedfilesout:{generatedDir}";
+        }
+    }
+}
+
+internal sealed class ReplayOptions(
+    string pipeName,
+    string clientDirectory,
+    string outputDirectory,
+    string binlogPath,
+    int maxParallel)
+{
+    internal string PipeName { get; } = pipeName;
+    internal string ClientDirectory { get; } = clientDirectory;
+    internal string OutputDirectory { get; } = outputDirectory;
+    internal string BinlogPath { get; } = binlogPath;
+    internal int MaxParallel { get; } = maxParallel;
+    internal string TempDirectory { get; } = Path.Combine(outputDirectory, "temp");
+}
+
+internal readonly struct BuildData(CompilerCall compilerCall, BuildResponse response)
+{
+    internal CompilerCall CompilerCall { get; } = compilerCall;
+    internal BuildResponse BuildResponse { get; } = response;
+}
diff --git a/src/Tools/Replay/Replay.csproj b/src/Tools/Replay/Replay.csproj
new file mode 100644
index 0000000000000..79a6869497ece
--- /dev/null
+++ b/src/Tools/Replay/Replay.csproj
@@ -0,0 +1,36 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>$(NetRoslyn);net472</TargetFrameworks>
+    <GenerateMicrosoftCodeAnalysisCommitHashAttribute>true</GenerateMicrosoftCodeAnalysisCommitHashAttribute>
+    <SignAssembly>false</SignAssembly>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="..\..\Compilers\Core\CommandLine\BuildProtocol.cs" />
+    <Compile Include="..\..\Compilers\Core\CommandLine\CompilerServerLogger.cs" />
+    <Compile Include="..\..\Compilers\Core\CommandLine\NativeMethods.cs" />
+    <Compile Include="..\..\Compilers\Core\Portable\CommitHashAttribute.cs" />
+    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\PlatformInformation.cs" />
+    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\Debug.cs" />
+    <Compile Include="..\..\Compilers\Core\Portable\InternalUtilities\NullableAttributes.cs" />
+    <Compile Include="..\..\Compilers\Shared\BuildServerConnection.cs" />
+    <Compile Include="..\..\Compilers\Shared\NamedPipeUtil.cs" />
+    <Compile Include="..\..\Compilers\Shared\RuntimeHostInfo.cs" />
+
+    <ProjectReference Include="..\..\Compilers\CSharp\csc\AnyCpu\csc.csproj">
+      <Aliases>csc</Aliases>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Compilers\VisualBasic\vbc\AnyCpu\vbc.csproj">
+      <Aliases>vbc</Aliases>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Compilers\Server\VBCSCompiler\AnyCpu\VBCSCompiler.csproj">
+      <Aliases>vbcscompiler</Aliases>
+    </ProjectReference>
+
+    <PackageReference Include="Mono.Options" />
+    <PackageReference Include="MSBuild.StructuredLogger" />
+    <PackageReference Include="Basic.CompilerLog.Util" />
+    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Condition="'$(TargetFramework)' == 'net472'" />
+  </ItemGroup>
+</Project>